/**
* Get the current time, measured in milliseconds since January 1, 1970 (UTC).
*
- * On browsers that implement the Navigation Timing API, this function will produce floating-point
- * values with microsecond precision that are guaranteed to be monotonic. On all other browsers,
- * it will fall back to using `Date`.
+ * On browsers that implement the Navigation Timing API, this function will produce
+ * floating-point values with microsecond precision that are guaranteed to be monotonic.
+ * On all other browsers, it will fall back to using `Date`.
*
* @return {number} Current time
*/
- now: ( function () {
+ now: function () {
+ // Optimisation: Define the shortcut on first call, not at module definition.
var perf = window.performance,
navStart = perf && perf.timing && perf.timing.navigationStart;
- return navStart && typeof perf.now === 'function' ?
+
+ // Define the relevant shortcut
+ mw.now = navStart && typeof perf.now === 'function' ?
function () { return navStart + perf.now(); } :
- function () { return Date.now(); };
- }() ),
+ Date.now;
+
+ return mw.now();
+ },
/**
* List of all analytic events emitted so far.
* The contents are then stashed in the registry via mw.loader#implement.
* - `loaded`:
* The module has been loaded from the server and stashed via mw.loader#implement.
- * If the module has no more dependencies in-flight, the module will be executed
- * immediately. Otherwise execution is deferred, controlled via #handlePending.
+ * Once the module has no more dependencies in-flight, the module will be executed,
+ * controlled via #requestPropagation and #doPropagation.
* - `executing`:
* The module is being executed.
* - `ready`:
/**
* List of callback jobs waiting for modules to be ready.
*
- * Jobs are created by #enqueue() and run by #handlePending().
- *
+ * Jobs are created by #enqueue() and run by #doPropagation().
* Typically when a job is created for a module, the job's dependencies contain
* both the required module and all its recursive dependencies.
*
*/
jobs = [],
+ // For #requestPropagation() and #doPropagation()
+ willPropagate = false,
+ errorModules = [],
+
/**
* @private
* @property {Array} baseModules
}
/**
- * 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, go ahead and execute
- * all jobs/modules now having their dependencies satisfied.
+ * Handle propagation of module state changes and reactions to them.
*
- * Jobs that depend on a failed module, will have their error callback ran (if any).
+ * - When a module reaches a failure state, this should be propagated to
+ * modules that depend on the failed module.
+ * - When a module reaches a final state, pending job callbacks for the
+ * module from mw.loader.using() should be called.
+ * - When a module reaches the 'ready' state from #execute(), consider
+ * executing dependant modules now having their dependencies satisfied.
+ * - When a module reaches the 'loaded' state from mw.loader.implement,
+ * consider executing it, if it has no unsatisfied dependencies.
*
* @private
- * @param {string} module Name of module that entered one of the states 'ready', 'error', or 'missing'.
*/
- function handlePending( module ) {
- var j, job, hasErrors, m, stateChange, fromBaseModule;
-
- if ( registry[ module ].state === 'error' || registry[ module ].state === 'missing' ) {
- fromBaseModule = baseModules.indexOf( module ) !== -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 ( registry[ m ].state !== 'error' && registry[ m ].state !== 'missing' ) {
- // Always propagate errors from base modules to regular modules (implicit dependency).
- // Between base modules or regular modules, consider direct dependencies only.
- if (
- ( fromBaseModule && baseModules.indexOf( m ) === -1 ) ||
- anyFailed( registry[ m ].dependencies )
- ) {
- registry[ m ].state = 'error';
- stateChange = true;
+ function doPropagation() {
+ var errorModule, baseModuleError, module, i, failed, job,
+ didPropagate = true;
+
+ // Keep going until the last iteration performed no actions.
+ do {
+ didPropagate = false;
+
+ // Stage 1: Propagate failures
+ while ( errorModules.length ) {
+ errorModule = errorModules.shift();
+ baseModuleError = baseModules.indexOf( errorModule ) !== -1;
+ for ( module in registry ) {
+ if ( registry[ module ].state !== 'error' && registry[ module ].state !== 'missing' ) {
+ if ( baseModuleError && baseModules.indexOf( module ) === -1 ) {
+ // Propate error from base module to all regular (non-base) modules
+ registry[ module ].state = 'error';
+ didPropagate = true;
+ } else if ( registry[ module ].dependencies.indexOf( errorModule ) !== -1 ) {
+ // Propagate error from dependency to depending module
+ registry[ module ].state = 'error';
+ // .. and propagate it further
+ errorModules.push( module );
+ didPropagate = true;
}
}
}
- } 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++ ) {
- hasErrors = anyFailed( jobs[ j ].dependencies );
- 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 ) {
- if ( typeof job.error === 'function' ) {
- job.error( new Error( 'Module ' + module + ' has failed dependencies' ), [ module ] );
- }
- } else {
- if ( typeof job.ready === 'function' ) {
+ // Stage 2: Execute 'loaded' modules with no unsatisfied dependencies
+ for ( module in registry ) {
+ if ( registry[ module ].state === 'loaded' && allWithImplicitReady( module ) ) {
+ // Recursively execute all dependent modules that were already loaded
+ // (waiting for execution) and no longer have unsatisfied dependencies.
+ // Base modules may have dependencies amongst eachother to ensure correct
+ // execution order. Regular modules wait for all base modules.
+ // eslint-disable-next-line no-use-before-define
+ execute( module );
+ didPropagate = true;
+ }
+ }
+
+ // Stage 3: Invoke job callbacks that are no longer blocked
+ for ( i = 0; i < jobs.length; i++ ) {
+ job = jobs[ i ];
+ failed = anyFailed( job.dependencies );
+ if ( failed || allReady( job.dependencies ) ) {
+ jobs.splice( i, 1 );
+ i -= 1;
+ try {
+ if ( failed && job.error ) {
+ job.error( new Error( 'Module has failed dependencies' ), job.dependencies );
+ } else if ( !failed && job.ready ) {
job.ready();
}
+ } catch ( e ) {
+ // A user-defined callback raised an exception.
+ // Swallow it to protect our state machine!
+ mw.trackError( 'resourceloader.exception', {
+ exception: e,
+ source: 'load-callback'
+ } );
}
- } catch ( e ) {
- // A user-defined callback raised an exception.
- // Swallow it to protect our state machine!
- mw.trackError( 'resourceloader.exception', {
- exception: e,
- module: module,
- source: 'load-callback'
- } );
+ didPropagate = true;
}
}
+ } while ( didPropagate );
+
+ willPropagate = false;
+ }
+
+ /**
+ * Request a (debounced) call to doPropagation().
+ *
+ * @private
+ */
+ function requestPropagation() {
+ if ( willPropagate ) {
+ // Already scheduled, or, we're already in a doPropagation stack.
+ return;
}
+ willPropagate = true;
+ // Yield for two reasons:
+ // * Allow successive calls to mw.loader.implement() from the same
+ // load.php response, or from the same asyncEval() to be in the
+ // propagation batch.
+ // * Allow the browser to breathe between the reception of
+ // module source code and the execution of it.
+ //
+ // Use a high priority because the user may be waiting for interactions
+ // to start being possible. But, first provide a moment (up to 'timeout')
+ // for native input event handling (e.g. scrolling/typing/clicking).
+ mw.requestIdleCallback( doPropagation, { timeout: 1 } );
+ }
- // The current module became 'ready'.
- if ( registry[ module ].state === 'ready' ) {
- // Queue it for later syncing to the module store.
- mw.loader.store.add( module );
- // Recursively execute all dependent modules that were already loaded
- // (waiting for execution) and no longer have unsatisfied dependencies.
- for ( m in registry ) {
- // Base modules may have dependencies amongst eachother to ensure correct
- // execution order. Regular modules wait for all base modules.
- if ( registry[ m ].state === 'loaded' && allWithImplicitReady( m ) ) {
- // eslint-disable-next-line no-use-before-define
- execute( m );
- }
+ /**
+ * Update a module's state in the registry and make sure any neccesary
+ * propagation will occur. See #doPropagation for more about propagation.
+ * See #registry for more about how states are used.
+ *
+ * @private
+ * @param {string} module
+ * @param {string} state
+ */
+ function setAndPropagate( module, state ) {
+ registry[ module ].state = state;
+ if ( state === 'loaded' || state === 'ready' || state === 'error' || state === 'missing' ) {
+ if ( state === 'ready' ) {
+ // Queue to later be synced to the local module store.
+ mw.loader.store.add( module );
+ } else if ( state === 'error' || state === 'missing' ) {
+ errorModules.push( module );
}
+ requestPropagation();
}
}
if ( skip() ) {
registry[ module ].skipped = true;
registry[ module ].dependencies = [];
- registry[ module ].state = 'ready';
- handlePending( module );
+ setAndPropagate( module, 'ready' );
return;
}
}
// Private modules must be embedded in the page. Don't bother queuing
// these as the server will deny them anyway (T101806).
if ( registry[ module ].group === 'private' ) {
- registry[ module ].state = 'error';
- handlePending( module );
+ setAndPropagate( module, 'error' );
return;
}
queue.push( module );
script = registry[ module ].script;
markModuleReady = function () {
$CODE.profileScriptEnd();
- registry[ module ].state = 'ready';
- handlePending( module );
+ setAndPropagate( module, 'ready' );
};
nestedAddScript = function ( arr, callback, i ) {
// Recursively call queueModuleScript() in its own callback
} catch ( e ) {
// Use mw.track instead of mw.log because these errors are common in production mode
// (e.g. undefined variable), and mw.log is only enabled in debug mode.
- registry[ module ].state = 'error';
+ setAndPropagate( module, 'error' );
$CODE.profileScriptEnd();
mw.trackError( 'resourceloader.exception', {
- exception: e, module:
- module, source: 'module-execute'
+ exception: e,
+ module: module,
+ source: 'module-execute'
} );
- handlePending( module );
}
};
/**
* Resolve indexed dependencies.
*
- * ResourceLoader uses an optimization to save space which replaces module names in
+ * ResourceLoader uses an optimisation to save space which replaces module names in
* dependency lists with the index of that module within the array of module
* registration data if it exists. The benefit is a significant reduction in the data
* size of the startup module. This function changes those dependency lists back to
};
}
+ /**
+ * @private
+ * @param {string} module
+ * @param {string|number} [version]
+ * @param {string[]} [dependencies]
+ * @param {string} [group]
+ * @param {string} [source]
+ * @param {string} [skip]
+ */
+ function registerOne( module, version, dependencies, group, source, skip ) {
+ if ( hasOwn.call( registry, module ) ) {
+ throw new Error( 'module already registered: ' + module );
+ }
+ registry[ module ] = {
+ // Exposed to execute() for mw.loader.implement() closures.
+ // Import happens via require().
+ module: {
+ exports: {}
+ },
+ version: String( version || '' ),
+ dependencies: dependencies || [],
+ group: typeof group === 'string' ? group : null,
+ source: typeof source === 'string' ? source : 'local',
+ state: 'registered',
+ skip: typeof skip === 'string' ? skip : null
+ };
+ }
+
/* Public Members */
return {
/**
/**
* Start loading of all queued module dependencies.
*
- * @protected
+ * @private
*/
work: function () {
var q, batch, implementations, sourceModules;
*
* The #work() method will use this information to split up requests by source.
*
- * mw.loader.addSource( 'mediawikiwiki', '//www.mediawiki.org/w/load.php' );
+ * mw.loader.addSource( { mediawikiwiki: 'https://www.mediawiki.org/w/load.php' } );
*
- * @param {string|Object} id Source ID, or object mapping ids to load urls
- * @param {string} loadUrl Url to a load.php end point
+ * @private
+ * @param {Object} ids An object mapping ids to load.php end point urls
* @throws {Error} If source id is already registered
*/
- addSource: function ( id, loadUrl ) {
- var source;
- // Allow multiple additions
- if ( typeof id === 'object' ) {
- for ( source in id ) {
- mw.loader.addSource( source, id[ source ] );
+ addSource: function ( ids ) {
+ var id;
+ for ( id in ids ) {
+ if ( hasOwn.call( sources, id ) ) {
+ throw new Error( 'source already registered: ' + id );
}
- return;
- }
-
- if ( hasOwn.call( sources, id ) ) {
- throw new Error( 'source already registered: ' + id );
+ sources[ id ] = ids[ id ];
}
-
- sources[ id ] = loadUrl;
},
/**
* Register a module, letting the system know about it and its properties.
*
- * The startup modules contain calls to this method.
+ * The startup module calls this method.
*
* When using multiple module registration by passing an array, dependencies that
* are specified as references to modules within the array will be resolved before
* the modules are registered.
*
- * @param {string|Array} module Module name or array of arrays, each containing
+ * @param {string|Array} modules Module name or array of arrays, each containing
* a list of arguments compatible with this method
- * @param {string|number} version Module version hash (falls backs to empty string)
+ * @param {string|number} [version] Module version hash (falls backs to empty string)
* Can also be a number (timestamp) for compatibility with MediaWiki 1.25 and earlier.
* @param {string[]} [dependencies] Array of module names on which this module depends.
* @param {string} [group=null] Group which the module is in
* @param {string} [source='local'] Name of the source
* @param {string} [skip=null] Script body of the skip function
*/
- register: function ( module, version, dependencies, group, source, skip ) {
+ register: function ( modules ) {
var i;
- // Allow multiple registration
- if ( typeof module === 'object' ) {
- resolveIndexedDependencies( module );
- // module is an array of arrays
- for ( i = 0; i < module.length; i++ ) {
- // module is an array of module names
- mw.loader.register.apply( mw.loader, module[ i ] );
+ if ( typeof modules === 'object' ) {
+ resolveIndexedDependencies( modules );
+ // Optimisation: Up to 55% faster.
+ // Typically called only once, and with a batch.
+ // See <https://gist.github.com/Krinkle/f06fdb3de62824c6c16f02a0e6ce0e66>
+ // Benchmarks taught us that the code for adding an object to `registry`
+ // should actually be inline, or in a simple function that does no
+ // arguments manipulation, and isn't also the caller itself.
+ // JS semantics make it hard to optimise recursion to a different
+ // signature of itself.
+ for ( i = 0; i < modules.length; i++ ) {
+ registerOne.apply( null, modules[ i ] );
}
- return;
+ } else {
+ registerOne.apply( null, arguments );
}
- if ( hasOwn.call( registry, module ) ) {
- throw new Error( 'module already registered: ' + module );
- }
- // List the module as registered
- registry[ module ] = {
- // Exposed to execute() for mw.loader.implement() closures.
- // Import happens via require().
- module: {
- exports: {}
- },
- version: String( version || '' ),
- dependencies: dependencies || [],
- group: typeof group === 'string' ? group : null,
- source: typeof source === 'string' ? source : 'local',
- state: 'registered',
- skip: typeof skip === 'string' ? skip : null
- };
},
/**
* The reason css strings are not concatenated anymore is T33676. We now check
* whether it's safe to extend the stylesheet.
*
- * @protected
+ * @private
* @param {Object} [messages] List of key/value pairs to be added to mw#messages.
* @param {Object} [templates] List of key/value pairs to be added to mw#templates.
*/
registry[ name ].templates = templates || null;
// The module may already have been marked as erroneous
if ( registry[ name ].state !== 'error' && registry[ name ].state !== 'missing' ) {
- registry[ name ].state = 'loaded';
- if ( allWithImplicitReady( name ) ) {
- execute( name );
- }
+ setAndPropagate( name, 'loaded' );
}
},
if ( !hasOwn.call( registry, module ) ) {
mw.loader.register( module );
}
- registry[ module ].state = state;
- if ( state === 'ready' || state === 'error' || state === 'missing' ) {
- // Make sure pending modules depending on this one get executed if their
- // dependencies are now fulfilled!
- handlePending( module );
- }
+ setAndPropagate( module, state );
}
},
// Disabled because localStorage quotas are tight and (in Firefox's case)
// shared by multiple origins.
// See T66721, and <https://bugzilla.mozilla.org/show_bug.cgi?id=1064466>.
- /Firefox|Opera/.test( navigator.userAgent ) ||
+ /Firefox/.test( navigator.userAgent ) ||
// Disabled by configuration.
!mw.config.get( 'wgResourceLoaderStorageEnabled' )