+/*jslint browser: true, continue: true, white: true, forin: true*/
+/*global jQuery*/
/*
* Core MediaWiki JavaScript Library
*/
var mw = ( function ( $, undefined ) {
-"use strict";
+ "use strict";
/* Private Members */
results[selection[i]] = this.get( selection[i], fallback );
}
return results;
- } else if ( typeof selection === 'string' ) {
+ }
+
+ if ( typeof selection === 'string' ) {
if ( this.values[selection] === undefined ) {
if ( fallback !== undefined ) {
return fallback;
}
return this.values[selection];
}
+
if ( selection === undefined ) {
return this.values;
- } else {
- return null; // invalid selection key
}
+
+ // invalid selection key
+ return null;
},
/**
this.values[s] = selection[s];
}
return true;
- } else if ( typeof selection === 'string' && value !== undefined ) {
+ }
+ if ( typeof selection === 'string' && value !== undefined ) {
this.values[selection] = value;
return true;
}
}
}
return true;
- } else {
- return this.values[selection] !== undefined;
}
+ return this.values[selection] !== undefined;
}
};
/**
* Simple message parser, does $N replacement and nothing else.
* This may be overridden to provide a more complex message parser.
- *
+ *
* This function will not be called for nonexistent messages.
*/
parser: function() {
return parameters[index] !== undefined ? parameters[index] : '$' + match;
} );
},
-
+
/**
* Appends (does not replace) parameters for replacement to the .parameters property.
*
* @return string Message as a string in the current form or <key> if key does not exist.
*/
toString: function() {
- if ( !this.exists( ) ) {
+ var text;
+
+ if ( !this.exists() ) {
// Use <key> as text if key does not exist
if ( this.format !== 'plain' ) {
// format 'escape' and 'parse' need to have the brackets and key html escaped
return '<' + this.key + '>';
}
- var text;
if ( this.format === 'plain' ) {
- // FIXME this is wrong. There should be a way
- // to tell parser() whether we're looking for
- // plain text or HTML, but I don't know jQueryMsg
- // well enough to implement this.
- // Currently it always outputs HTML
+ // @todo FIXME: Although not applicable to core Message,
+ // Plugins like jQueryMsg should be able to distinguish
+ // between 'plain' (only variable replacement and plural/gender)
+ // and actually parsing wikitext to HTML.
text = this.parser();
}
text = this.parser();
text = mw.html.escape( text );
}
-
+
if ( this.format === 'parse' ) {
text = this.parser();
}
* emulates console.log in console-less environments.
*/
log: function() { },
-
+
/**
* @var constructor Make the Map constructor publicly available.
*/
* @var constructor Make the Message constructor publicly available.
*/
Message: Message,
-
+
/**
* List of configuration values
*
* in the global window object.
*/
config: null,
-
+
/**
* @var object
*
* Empty object that plugins can be installed in.
*/
libs: {},
-
+
/* Extension points */
-
+
legacy: {},
-
+
/**
* Localization system
*/
messages: new Map(),
-
+
/* Public Methods */
-
+
/**
* Gets a message object, similar to wfMessage()
*
}
return new Message( mw.messages, key, parameters );
},
-
+
/**
* Gets a message string, similar to wfMsg()
*
* each a parameter for $N replacement in messages.
* @return String.
*/
- msg: function ( key, parameters ) {
+ msg: function ( /* key, parameter_1, parameter_2, .. */ ) {
return mw.message.apply( mw.message, arguments ).toString();
},
-
+
/**
* Client-side module loader which integrates with the MediaWiki ResourceLoader
*/
- loader: ( function() {
-
+ loader: ( function () {
+
/* Private Members */
-
+
/**
* Mapping of registered modules
*
jobs = [],
// Flag indicating that document ready has occured
ready = false,
- // Whether we should try to load scripts in a blocking way
- // Set with setBlocking()
- blocking = false,
// Selector cache for the marker element. Use getMarker() to get/use the marker!
$marker = null;
-
+
/* Cache document ready status */
-
+
$(document).ready( function () {
ready = true;
} );
-
+
/* Private methods */
-
- function getMarker(){
+
+ function getMarker() {
// Cached ?
if ( $marker ) {
return $marker;
+ }
+
+ $marker = $( 'meta[name="ResourceLoaderDynamicStyles"]' );
+ if ( $marker.length ) {
+ return $marker;
+ }
+ mw.log( 'getMarker> No <meta name="ResourceLoaderDynamicStyles"> found, inserting dynamically.' );
+ $marker = $( '<meta>' ).attr( 'name', 'ResourceLoaderDynamicStyles' ).appendTo( 'head' );
+
+ return $marker;
+ }
+
+ /**
+ * Create a new style tag and add it to the DOM.
+ *
+ * @param text String: CSS text
+ * @param $nextnode mixed: [optional] An Element or jQuery object for an element where
+ * the style tag should be inserted before. Otherwise appended to the <head>.
+ * @return HTMLStyleElement
+ */
+ function addStyleTag( text, $nextnode ) {
+ var s = document.createElement( 'style' );
+ s.type = 'text/css';
+ s.rel = 'stylesheet';
+ // Insert into document before setting cssText (bug 33305)
+ if ( $nextnode ) {
+ // If a raw element, create a jQuery object, otherwise use directly
+ if ( $nextnode.nodeType ) {
+ $nextnode = $( $nextnode );
+ }
+ $nextnode.before( s );
+ } else {
+ document.getElementsByTagName('head')[0].appendChild( s );
+ }
+ if ( s.styleSheet ) {
+ s.styleSheet.cssText = text; // IE
} else {
- $marker = $( 'meta[name="ResourceLoaderDynamicStyles"]' );
- if ( $marker.length ) {
- return $marker;
+ // Safari sometimes borks on null
+ s.appendChild( document.createTextNode( String( text ) ) );
+ }
+ return s;
+ }
+
+ function addInlineCSS( css ) {
+ var $style, style, $newStyle;
+ $style = getMarker().prev();
+ // Disable <style> tag recycling/concatenation because of bug 34669
+ if ( false && $style.is( 'style' ) && $style.data( 'ResourceLoaderDynamicStyleTag' ) === true ) {
+ // There's already a dynamic <style> tag present, append to it. This recycling of
+ // <style> tags is for bug 31676 (can't have more than 32 <style> tags in IE)
+ style = $style.get( 0 );
+ if ( style.styleSheet ) {
+ style.styleSheet.cssText += css; // IE
+ } else {
+ style.appendChild( document.createTextNode( String( css ) ) );
}
- mw.log( 'getMarker> No <meta name="ResourceLoaderDynamicStyles"> found, inserting dynamically.' );
- $marker = $( '<meta>' ).attr( 'name', 'ResourceLoaderDynamicStyles' ).appendTo( 'head' );
- return $marker;
+ } else {
+ $newStyle = $( addStyleTag( css, getMarker() ) )
+ .data( 'ResourceLoaderDynamicStyleTag', true );
}
}
-
+
function compare( a, b ) {
var i;
if ( a.length !== b.length ) {
}
return true;
}
-
+
/**
* Generates an ISO8601 "basic" string from a UNIX timestamp
*/
pad( d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds() ), 'Z'
].join( '' );
}
-
+
/**
- * Recursively resolves dependencies and detects circular references
+ * Resolves dependencies and detects circular references.
+ *
+ * @param module String Name of the top-level module whose dependencies shall be
+ * resolved and sorted.
+ * @param resolved Array Returns a topological sort of the given module and its
+ * dependencies, such that later modules depend on earlier modules. The array
+ * contains the module names. If the array contains already some module names,
+ * this function appends its result to the pre-existing array.
+ * @param unresolved Object [optional] Hash used to track the current dependency
+ * chain; used to report loops in the dependency graph.
+ * @throws Error if any unregistered module or a dependency loop is encountered
*/
- function recurse( module, resolved, unresolved ) {
+ function sortDependencies( module, resolved, unresolved ) {
var n, deps, len;
-
+
if ( registry[module] === undefined ) {
throw new Error( 'Unknown dependency: ' + module );
}
registry[module].dependencies = [registry[module].dependencies];
}
}
+ if ( $.inArray( module, resolved ) !== -1 ) {
+ // Module already resolved; nothing to do.
+ return;
+ }
+ // unresolved is optional, supply it if not passed in
+ if ( !unresolved ) {
+ unresolved = {};
+ }
// Tracks down dependencies
deps = registry[module].dependencies;
len = deps.length;
for ( n = 0; n < len; n += 1 ) {
if ( $.inArray( deps[n], resolved ) === -1 ) {
- if ( $.inArray( deps[n], unresolved ) !== -1 ) {
+ if ( unresolved[deps[n]] ) {
throw new Error(
'Circular reference detected: ' + module +
' -> ' + deps[n]
}
// Add to unresolved
- unresolved[unresolved.length] = module;
- recurse( deps[n], resolved, unresolved );
- // module is at the end of unresolved
- unresolved.pop();
+ unresolved[module] = true;
+ sortDependencies( deps[n], resolved, unresolved );
+ delete unresolved[module];
}
}
resolved[resolved.length] = module;
}
-
+
/**
- * Gets a list of module names that a module depends on in their proper dependency order
+ * Gets a list of module names that a module depends on in their proper dependency
+ * order.
*
* @param module string module name or array of string module names
* @return list of dependencies, including 'module'.
* @throws Error if circular reference is detected
*/
function resolve( module ) {
- var modules, m, deps, n, resolved;
-
+ var m, resolved;
+
// Allow calling with an array of module names
if ( $.isArray( module ) ) {
- modules = [];
+ resolved = [];
for ( m = 0; m < module.length; m += 1 ) {
- deps = resolve( module[m] );
- for ( n = 0; n < deps.length; n += 1 ) {
- modules[modules.length] = deps[n];
- }
+ sortDependencies( module[m], resolved );
}
- return modules;
- } else if ( typeof module === 'string' ) {
+ return resolved;
+ }
+
+ if ( typeof module === 'string' ) {
resolved = [];
- recurse( module, resolved, [] );
+ sortDependencies( module, resolved );
return resolved;
}
+
throw new Error( 'Invalid module argument: ' + module );
}
-
+
/**
* Narrows a list of module names down to those matching a specific
* state (see comment on top of this scope for a list of valid states).
*/
function filter( states, modules ) {
var list, module, s, m;
-
+
// Allow states to be given as a string
if ( typeof states === 'string' ) {
states = [states];
}
return list;
}
-
+
+ /**
+ * Determine whether all dependencies are in state 'ready', which means we may
+ * execute the module or job now.
+ *
+ * @param dependencies Array dependencies (module names) to be checked.
+ *
+ * @return Boolean true if all dependencies are in state 'ready', false otherwise
+ */
+ function allReady( dependencies ) {
+ return filter( 'ready', dependencies ).length === dependencies.length;
+ }
+
+ /**
+ * Log a message to window.console, if possible. Useful to force logging of some
+ * errors that are otherwise hard to detect, even if mw.log is not available. (I.e.,
+ * this logs also if not in debug mode.)
+ *
+ * @param msg String text for the log entry
+ * @param e Error [optional] to also log.
+ */
+ function log( msg, e ) {
+ if ( window.console && typeof window.console.log === 'function' ) {
+ console.log( msg );
+ if ( e ) {
+ console.log( e );
+ }
+ }
+ }
+
/**
- * Automatically executes jobs and modules which are pending with satistifed dependencies.
+ * A module has entered state 'ready', 'error', or 'missing'. Automatically update pending jobs
+ * and modules that depend upon this module. if the given module failed, propagate the 'error'
+ * state up the dependency tree; otherwise, execute all jobs/modules that now have all their
+ * dependencies satisfied. On jobs depending on a failed module, run the error callback, if any.
*
- * This is used when dependencies are satisfied, such as when a module is executed.
+ * @param module String name of module that entered one of the states 'ready', 'error', or 'missing'.
*/
function handlePending( module ) {
- var j, r;
-
- try {
- // Run jobs who's dependencies have just been met
- for ( j = 0; j < jobs.length; j += 1 ) {
- if ( compare(
- filter( 'ready', jobs[j].dependencies ),
- jobs[j].dependencies ) )
- {
- if ( $.isFunction( jobs[j].ready ) ) {
- jobs[j].ready();
+ var j, job, hasErrors, m, stateChange;
+
+ // Modules.
+ if ( $.inArray( registry[module].state, ['error', 'missing'] ) !== -1 ) {
+ // If the current module failed, mark all dependent modules also as failed.
+ // Iterate until steady-state to propagate the error state upwards in the
+ // dependency tree.
+ do {
+ stateChange = false;
+ for ( m in registry ) {
+ if ( $.inArray( registry[m].state, ['error', 'missing'] ) === -1 ) {
+ if ( filter( ['error', 'missing'], registry[m].dependencies ).length > 0 ) {
+ registry[m].state = 'error';
+ stateChange = true;
+ }
}
- jobs.splice( j, 1 );
- j -= 1;
}
- }
- // Execute modules who's dependencies have just been met
- for ( r in registry ) {
- if ( registry[r].state === 'loaded' ) {
- if ( compare(
- filter( ['ready'], registry[r].dependencies ),
- registry[r].dependencies ) )
- {
- execute( r );
+ } while ( stateChange );
+ }
+
+ // Execute all jobs whose dependencies are either all satisfied or contain at least one failed module.
+ for ( j = 0; j < jobs.length; j += 1 ) {
+ hasErrors = filter( ['error', 'missing'], jobs[j].dependencies ).length > 0;
+ if ( hasErrors || allReady( jobs[j].dependencies ) ) {
+ // All dependencies satisfied, or some have errors
+ job = jobs[j];
+ jobs.splice( j, 1 );
+ j -= 1;
+ try {
+ if ( hasErrors ) {
+ throw new Error ("Module " + module + " failed.");
+ } else {
+ if ( $.isFunction( job.ready ) ) {
+ job.ready();
+ }
+ }
+ } catch ( e ) {
+ if ( $.isFunction( job.error ) ) {
+ try {
+ job.error( e, [module] );
+ } catch ( ex ) {
+ // A user-defined operation raised an exception. Swallow to protect
+ // our state machine!
+ log( 'mw.loader::handlePending> Exception thrown by job.error()', ex );
+ }
}
}
}
- } catch ( e ) {
- // Run error callbacks of jobs affected by this condition
- for ( j = 0; j < jobs.length; j += 1 ) {
- if ( $.inArray( module, jobs[j].dependencies ) !== -1 ) {
- if ( $.isFunction( jobs[j].error ) ) {
- jobs[j].error( e, module );
- }
- jobs.splice( j, 1 );
- j -= 1;
+ }
+
+ if ( registry[module].state === 'ready' ) {
+ // The current module became 'ready'. Recursively execute all dependent modules that are loaded
+ // and now have all dependencies satisfied.
+ for ( m in registry ) {
+ if ( registry[m].state === 'loaded' && allReady( registry[m].dependencies ) ) {
+ execute( m );
}
}
}
}
-
+
/**
* Adds a script tag to the DOM, either using document.write or low-level DOM manipulation,
- * depending on whether document-ready has occured yet and whether we are in blocking mode.
+ * depending on whether document-ready has occurred yet and whether we are in async mode.
*
* @param src String: URL to script, will be used as the src attribute in the script tag
* @param callback Function: Optional callback which will be run when the script is done
*/
- function addScript( src, callback ) {
+ function addScript( src, callback, async ) {
var done = false, script, head;
- if ( ready || !blocking ) {
+ if ( ready || async ) {
// jQuery's getScript method is NOT better than doing this the old-fashioned way
// because jQuery will eval the script's code, and errors will not have sane
// line numbers.
if ( $.isFunction( callback ) ) {
// Attach handlers for all browsers (based on jQuery.ajax)
script.onload = script.onreadystatechange = function() {
-
+
if (
!done
&& (
|| /loaded|complete/.test( script.readyState )
)
) {
-
+
done = true;
-
- // Handle memory leak in IE
- script.onload = script.onreadystatechange = null;
-
+
callback();
-
- if ( script.parentNode ) {
- script.parentNode.removeChild( script );
- }
-
- // Dereference the script
- script = undefined;
+
+ // Handle memory leak in IE. This seems to fail in
+ // IE7 sometimes (Permission Denied error when
+ // accessing script.parentNode) so wrap it in
+ // a try catch.
+ try {
+ script.onload = script.onreadystatechange = null;
+ if ( script.parentNode ) {
+ script.parentNode.removeChild( script );
+ }
+
+ // Dereference the script
+ script = undefined;
+ } catch ( e ) { }
}
};
}
- // IE-safe way of getting the <head> . document.documentElement.head doesn't
- // work in scripts that run in the <head>
- head = document.getElementsByTagName( 'head' )[0];
- // Append to the <body> if available, to the <head> otherwise
- (document.body || head).appendChild( script );
+
+ if ( window.opera ) {
+ // Appending to the <head> blocks rendering completely in Opera,
+ // so append to the <body> after document ready. This means the
+ // scripts only start loading after the document has been rendered,
+ // but so be it. Opera users don't deserve faster web pages if their
+ // browser makes it impossible
+ $( function() { document.body.appendChild( script ); } );
+ } else {
+ // IE-safe way of getting the <head> . document.documentElement.head doesn't
+ // work in scripts that run in the <head>
+ head = document.getElementsByTagName( 'head' )[0];
+ ( document.body || head ).appendChild( script );
+ }
} else {
document.write( mw.html.element(
'script', { 'type': 'text/javascript', 'src': src }, ''
}
}
}
-
+
/**
* Executes a loaded module, making it ready to use
*
* @param module string module name to execute
*/
- function execute( module, callback ) {
+ function execute( module ) {
var style, media, i, script, markModuleReady, nestedAddScript;
-
+
if ( registry[module] === undefined ) {
throw new Error( 'Module has not been registered yet: ' + module );
} else if ( registry[module].state === 'registered' ) {
} else if ( registry[module].state === 'ready' ) {
throw new Error( 'Module has already been loaded: ' + module );
}
-
+
// Add styles
if ( $.isPlainObject( registry[module].style ) ) {
+ // 'media' type ignored, see documentation of mw.loader.implement
for ( media in registry[module].style ) {
style = registry[module].style[media];
if ( $.isArray( style ) ) {
for ( i = 0; i < style.length; i += 1 ) {
getMarker().before( mw.html.element( 'link', {
'type': 'text/css',
- 'media': media,
'rel': 'stylesheet',
'href': style[i]
} ) );
}
} else if ( typeof style === 'string' ) {
- getMarker().before( mw.html.element( 'style', {
- 'type': 'text/css',
- 'media': media
- }, new mw.html.Cdata( style ) ) );
+ addInlineCSS( style );
}
}
}
markModuleReady = function() {
registry[module].state = 'ready';
handlePending( module );
- if ( $.isFunction( callback ) ) {
- callback();
- }
};
- nestedAddScript = function ( arr, callback, i ) {
+ nestedAddScript = function ( arr, callback, async, i ) {
// Recursively call addScript() in its own callback
// for each element of arr.
if ( i >= arr.length ) {
callback();
return;
}
-
+
addScript( arr[i], function() {
- nestedAddScript( arr, callback, i + 1 );
- } );
+ nestedAddScript( arr, callback, async, i + 1 );
+ }, async );
};
-
+
if ( $.isArray( script ) ) {
registry[module].state = 'loading';
- nestedAddScript( script, markModuleReady, 0 );
+ nestedAddScript( script, markModuleReady, registry[module].async, 0 );
} else if ( $.isFunction( script ) ) {
script( $ );
markModuleReady();
} catch ( e ) {
// This needs to NOT use mw.log because these errors are common in production mode
// and not in debug mode, such as when a symbol that should be global isn't exported
- if ( window.console && typeof window.console.log === 'function' ) {
- console.log( 'mw.loader::execute> Exception thrown by ' + module + ': ' + e.message );
- }
+ log('mw.loader::execute> Exception thrown by ' + module + ': ' + e.message, e);
registry[module].state = 'error';
- throw e;
+ handlePending( module );
}
}
-
+
/**
* Adds a dependencies to the queue with optional callbacks to be run
* when the dependencies are ready or fail
* @param dependencies string module name or array of string module names
* @param ready function callback to execute when all dependencies are ready
* @param error function callback to execute when any dependency fails
+ * @param async (optional) If true, load modules asynchronously even if
+ * document ready has not yet occurred
*/
- function request( dependencies, ready, error ) {
+ function request( dependencies, ready, error, async ) {
var regItemDeps, regItemDepLen, n;
-
+
// Allow calling by single module name
if ( typeof dependencies === 'string' ) {
dependencies = [dependencies];
}
}
}
+
// Add ready and error callbacks if they were given
- if ( arguments.length > 1 ) {
+ if ( ready !== undefined || error !== undefined ) {
jobs[jobs.length] = {
'dependencies': filter(
['registered', 'loading', 'loaded'],
'error': error
};
}
+
// Queue up any dependencies that are registered
dependencies = filter( ['registered'], dependencies );
for ( n = 0; n < dependencies.length; n += 1 ) {
if ( $.inArray( dependencies[n], queue ) === -1 ) {
queue[queue.length] = dependencies[n];
+ if ( async ) {
+ // Mark this module as async in the registry
+ registry[dependencies[n]].async = true;
+ }
}
}
+
// Work the queue
mw.loader.work();
}
-
+
function sortQuery(o) {
var sorted = {}, key, a = [];
for ( key in o ) {
}
return sorted;
}
-
+
/**
* Converts a module map of the form { foo: [ 'bar', 'baz' ], bar: [ 'baz, 'quux' ] }
* to a query string of the form foo.bar,baz|bar.baz,quux
}
return arr.join( '|' );
}
-
+
/**
* Asynchronously append a script tag to the end of the body
* that invokes load.php
* @param moduleMap {Object}: Module map, see buildModulesString()
* @param currReqBase {Object}: Object with other parameters (other than 'modules') to use in the request
* @param sourceLoadScript {String}: URL of load.php
+ * @param async {Boolean}: If true, use an asynchrounous request even if document ready has not yet occurred
*/
- function doRequest( moduleMap, currReqBase, sourceLoadScript ) {
+ function doRequest( moduleMap, currReqBase, sourceLoadScript, async ) {
var request = $.extend(
{ 'modules': buildModulesString( moduleMap ) },
currReqBase
request = sortQuery( request );
// Asynchronously append a script tag to the end of the body
// Append &* to avoid triggering the IE6 extension check
- addScript( sourceLoadScript + '?' + $.param( request ) + '&*' );
+ addScript( sourceLoadScript + '?' + $.param( request ) + '&*', null, async );
}
-
+
/* Public Methods */
return {
+ addStyleTag: addStyleTag,
+
/**
* Requests dependencies from server, loading and executing when things when ready.
*/
var reqBase, splits, maxQueryLength, q, b, bSource, bGroup, bSourceGroup,
source, group, g, i, modules, maxVersion, sourceLoadScript,
currReqBase, currReqBaseLength, moduleMap, l,
- lastDotIndex, prefix, suffix, bytesAdded;
-
+ lastDotIndex, prefix, suffix, bytesAdded, async;
+
// Build a list of request parameters common to all requests.
reqBase = {
skin: mw.config.get( 'skin' ),
// Split module batch by source and by group.
splits = {};
maxQueryLength = mw.config.get( 'wgResourceLoaderMaxQueryLength', -1 );
-
+
// Appends a list of modules from the queue to the batch
for ( q = 0; q < queue.length; q += 1 ) {
// Only request modules which are registered
if ( !batch.length ) {
return;
}
-
+
// The queue has been processed into the batch, clear up the queue.
queue = [];
-
+
// Always order modules alphabetically to help reduce cache
// misses for otherwise identical content.
batch.sort();
-
+
// Split batch by source and by group.
for ( b = 0; b < batch.length; b += 1 ) {
bSource = registry[batch[b]].source;
bSourceGroup = splits[bSource][bGroup];
bSourceGroup[bSourceGroup.length] = batch[b];
}
-
+
// Clear the batch - this MUST happen before we append any
// script elements to the body or it's possible that a script
// will be locally cached, instantly load, and work the batch
// again, all before we've cleared it causing each request to
// include modules which are already loaded.
batch = [];
-
+
for ( source in splits ) {
-
+
sourceLoadScript = sources[source].loadScript;
-
+
for ( group in splits[source] ) {
-
+
// Cache access to currently selected list of
// modules for this group from this source.
modules = splits[source][group];
-
+
// Calculate the highest timestamp
maxVersion = 0;
for ( g = 0; g < modules.length; g += 1 ) {
maxVersion = registry[modules[g]].version;
}
}
-
+
currReqBase = $.extend( { 'version': formatVersionNumber( maxVersion ) }, reqBase );
+ // For user modules append a user name to the request.
+ if ( group === "user" && mw.config.get( 'wgUserName' ) !== null ) {
+ currReqBase.user = mw.config.get( 'wgUserName' );
+ }
currReqBaseLength = $.param( currReqBase ).length;
- moduleMap = {};
+ async = true;
// We may need to split up the request to honor the query string length limit,
// so build it piece by piece.
l = currReqBaseLength + 9; // '&modules='.length == 9
-
+
moduleMap = {}; // { prefix: [ suffixes ] }
-
+
for ( i = 0; i < modules.length; i += 1 ) {
// Determine how many bytes this module would add to the query string
lastDotIndex = modules[i].lastIndexOf( '.' );
bytesAdded = moduleMap[prefix] !== undefined
? suffix.length + 3 // '%2C'.length == 3
: modules[i].length + 3; // '%7C'.length == 3
-
+
// If the request would become too long, create a new one,
// but don't create empty requests
if ( maxQueryLength > 0 && !$.isEmptyObject( moduleMap ) && l + bytesAdded > maxQueryLength ) {
// This request would become too long, create a new one
// and fire off the old one
- doRequest( moduleMap, currReqBase, sourceLoadScript );
+ doRequest( moduleMap, currReqBase, sourceLoadScript, async );
moduleMap = {};
+ async = true;
l = currReqBaseLength + 9;
}
if ( moduleMap[prefix] === undefined ) {
moduleMap[prefix] = [];
}
moduleMap[prefix].push( suffix );
+ if ( !registry[modules[i]].async ) {
+ // If this module is blocking, make the entire request blocking
+ // This is slightly suboptimal, but in practice mixing of blocking
+ // and async modules will only occur in debug mode.
+ async = false;
+ }
l += bytesAdded;
}
// If there's anything left in moduleMap, request that too
if ( !$.isEmptyObject( moduleMap ) ) {
- doRequest( moduleMap, currReqBase, sourceLoadScript );
+ doRequest( moduleMap, currReqBase, sourceLoadScript, async );
}
}
}
},
-
+
/**
* Register a source.
*
}
return true;
}
-
+
if ( sources[id] !== undefined ) {
throw new Error( 'source already registered: ' + id );
}
-
+
sources[id] = props;
-
+
return true;
},
-
+
/**
* Registers a module, letting the system know about it and its
* properties. Startup modules contain calls to this function.
registry[module].dependencies = dependencies;
}
},
-
+
/**
* Implements a module, giving the system a course of action to take
* upon loading. Results of a request for one or more modules contain
* @param script Mixed: Function of module code or String of URL to be used as the src
* attribute when adding a script element to the body
* @param style Object: Object of CSS strings keyed by media-type or Object of lists of URLs
- * keyed by media-type
+ * keyed by media-type. Media-type should be "all" or "", actual types are not supported
+ * right now due to the way execute() processes the stylesheets (they are concatenated
+ * into a single <style> tag). In the past these weren't concatenated together (which is
+ * these are keyed by media-type), but bug 31676 forces us to. In practice this is not a
+ * problem because ResourceLoader only generates stylesheets for media-type all (e.g. print
+ * stylesheets are wrapped in @media print {} and concatenated with the others).
* @param msgs Object: List of key/value pairs to be passed through mw.messages.set
*/
implement: function ( module, script, style, msgs ) {
if ( registry[module] !== undefined && registry[module].script !== undefined ) {
throw new Error( 'module already implemented: ' + module );
}
- // Mark module as loaded
- registry[module].state = 'loaded';
// Attach components
registry[module].script = script;
registry[module].style = style;
registry[module].messages = msgs;
- // Execute or queue callback
- if ( compare(
- filter( ['ready'], registry[module].dependencies ),
- registry[module].dependencies ) )
- {
- execute( module );
+ // The module may already have been marked as erroneous
+ if ( $.inArray( registry[module].state, ['error', 'missing'] ) === -1 ) {
+ registry[module].state = 'loaded';
+ if ( allReady( registry[module].dependencies ) ) {
+ execute( module );
+ }
}
},
-
+
/**
* Executes a function as soon as one or more required modules are ready
*
}
// Resolve entire dependency map
dependencies = resolve( dependencies );
- // If all dependencies are met, execute ready immediately
- if ( compare( filter( ['ready'], dependencies ), dependencies ) ) {
+ if ( allReady( dependencies ) ) {
+ // Run ready immediately
if ( $.isFunction( ready ) ) {
ready();
}
- }
- // If any dependencies have errors execute error immediately
- else if ( filter( ['error'], dependencies ).length ) {
+ } else if ( filter( ['error', 'missing'], dependencies ).length ) {
+ // Execute error immediately if any dependencies have errors
if ( $.isFunction( error ) ) {
- error( new Error( 'one or more dependencies have state "error"' ),
+ error( new Error( 'one or more dependencies have state "error" or "missing"' ),
dependencies );
}
- }
- // Since some dependencies are not yet ready, queue up a request
- else {
+ } else {
+ // Not all dependencies are ready: queue up a request
request( dependencies, ready, error );
}
},
-
+
/**
* Loads an external script or one or more modules for future use
*
* @param type {String} mime-type to use if calling with a URL of an
* external script or style; acceptable values are "text/css" and
* "text/javascript"; if no type is provided, text/javascript is assumed.
+ * @param async {Boolean} (optional) If true, load modules asynchronously
+ * even if document ready has not yet occurred. If false (default),
+ * block before document ready and load async after. If not set, true will
+ * be assumed if loading a URL, and false will be assumed otherwise.
*/
- load: function ( modules, type ) {
- var filtered, m;
+ load: function ( modules, type, async ) {
+ var filtered, m, module;
// Validate input
if ( typeof modules !== 'object' && typeof modules !== 'string' ) {
if ( typeof modules === 'string' ) {
// Support adding arbitrary external scripts
if ( /^(https?:)?\/\//.test( modules ) ) {
+ if ( async === undefined ) {
+ // Assume async for bug 34542
+ async = true;
+ }
if ( type === 'text/css' ) {
$( 'head' ).append( $( '<link>', {
rel: 'stylesheet',
href: modules
} ) );
return;
- } else if ( type === 'text/javascript' || type === undefined ) {
- addScript( modules );
+ }
+ if ( type === 'text/javascript' || type === undefined ) {
+ addScript( modules, null, async );
return;
}
// Unknown type
// an array of unrelated modules, whereas the modules passed to
// using() are related and must all be loaded.
for ( filtered = [], m = 0; m < modules.length; m += 1 ) {
- if ( registry[modules[m]] !== undefined ) {
- filtered[filtered.length] = modules[m];
+ module = registry[modules[m]];
+ if ( module !== undefined ) {
+ if ( $.inArray( module.state, ['error', 'missing'] ) === -1 ) {
+ filtered[filtered.length] = modules[m];
+ }
}
}
- // Resolve entire dependency map
- filtered = resolve( filtered );
- // If all modules are ready, nothing dependency be done
- if ( compare( filter( ['ready'], filtered ), filtered ) ) {
+ if (filtered.length === 0) {
return;
}
- // If any modules have errors
- else if ( filter( ['error'], filtered ).length ) {
+ // Resolve entire dependency map
+ filtered = resolve( filtered );
+ // If all modules are ready, nothing to be done
+ if ( allReady( filtered ) ) {
return;
}
- // Since some modules are not yet ready, queue up a request
- else {
- request( filtered );
+ // If any modules have errors: also quit.
+ if ( filter( ['error', 'missing'], filtered ).length ) {
return;
}
+ // Since some modules are not yet ready, queue up a request.
+ request( filtered, null, null, async );
},
-
+
/**
* Changes the state of a module
*
*/
state: function ( module, state ) {
var m;
+
if ( typeof module === 'object' ) {
for ( m in module ) {
mw.loader.state( m, module[m] );
if ( registry[module] === undefined ) {
mw.loader.register( module );
}
- registry[module].state = state;
+ if ( $.inArray(state, ['ready', 'error', 'missing']) !== -1
+ && registry[module].state !== state ) {
+ // Make sure pending modules depending on this one get executed if their
+ // dependencies are now fulfilled!
+ registry[module].state = state;
+ handlePending( module );
+ } else {
+ registry[module].state = state;
+ }
},
-
+
/**
* Gets the version of a module
*
}
return null;
},
-
+
/**
* @deprecated since 1.18 use mw.loader.getVersion() instead
*/
version: function () {
return mw.loader.getVersion.apply( mw.loader, arguments );
},
-
+
/**
* Gets the state of a module
*
}
return null;
},
-
+
/**
* Get names of all registered modules.
*
} );
},
- /**
- * Enable or disable blocking. If blocking is enabled and
- * document ready has not yet occurred, scripts will be loaded
- * in a blocking way (using document.write) rather than
- * asynchronously using DOM manipulation
- *
- * @param b {Boolean} True to enable blocking, false to disable it
- */
- setBlocking: function( b ) {
- blocking = b;
- },
-
/**
* For backwards-compatibility with Squid-cached pages. Loads mw.user
*/
}
};
}() ),
-
+
/** HTML construction helper functions */
html: ( function () {
function escapeCallback( s ) {
escape: function ( s ) {
return s.replace( /['"<>&]/g, escapeCallback );
},
-
+
/**
* Wrapper object for raw HTML passed to mw.html.element().
* @constructor
Raw: function ( value ) {
this.value = value;
},
-
+
/**
* Wrapper object for CDATA element contents passed to mw.html.element()
* @constructor
Cdata: function ( value ) {
this.value = value;
},
-
+
/**
* Create an HTML element string, with safe escaping.
*
*/
element: function ( name, attrs, contents ) {
var v, attrName, s = '<' + name;
-
+
for ( attrName in attrs ) {
v = attrs[attrName];
// Convert name=true, to name=name
return s;
}
};
- })()
+ }() ),
+
+ // Skeleton user object. mediawiki.user.js extends this
+ user: {
+ options: new Map(),
+ tokens: new Map()
+ }
};
-
-})( jQuery );
+
+}( jQuery ) );
// Alias $j to jQuery for backwards compatibility
window.$j = jQuery;
window.mw = window.mediaWiki = mw;
// Auto-register from pre-loaded startup scripts
-if ( typeof startUp !== 'undefined' && jQuery.isFunction( startUp ) ) {
- startUp();
- startUp = undefined;
+if ( jQuery.isFunction( window.startUp ) ) {
+ window.startUp();
+ window.startUp = undefined;
}
dépôts / lhc / web / wiklou.git / blobdiff