goog.module.ModuleManager

Register an extra runtime module dependency. After an extra edge is added, any subsequent calls to load or loadMultiple will fetch toModule if the fromModule was loaded.

The mechanism for this is implementation dependent. If the implementation does not support extra edges, it will throw an error.

Method called just before module code is loaded.

Disposes of the object and its resources.

Requests that a function be called once a particular module is loaded. Client code can use this method to safely call into modules that may not yet be loaded. For consistency, this method always calls the function asynchronously -- even if the module is already loaded. Initiates loading of the module if necessary, unless opt_noLoad is true.

Gets the application-specific module loader.

Gets the module context to use to initialize the module.

Gets a module info object by id.

Determines if the ModuleManager is active

Gets whether a module is currently loading or in the queue, waiting to be loaded.

Determines if the ModuleManager is user active

Loads a module, returning an IThenable for keeping track of the result.

Loads a list of modules, returning a map of IThenables for keeping track of the results.

Prefetches a JavaScript module and its dependencies, which means that the module will be downloaded, but not evaluated. To complete the module load, the caller should also call load or execOnLoad after prefetching the module.

Preloads a module after a short delay.

The function to call if the module manager is in error.

Register an initialization callback for the currently loading module. This should only be called by script that is executed during the evaluation of a module's javascript. This is almost equivalent to calling the function inline, but ensures that all the code from the currently loading module has been loaded. This makes it cleaner and more robust than calling the function inline.

If this function is called from the base module (the one that contains the module manager code), the callback is held until #setAllModuleInfo is called, or until #setModuleContext is called, whichever happens first.

Register a late initialization callback for the currently loading module. Callbacks registered via this function are executed similar to registerInitializationCallback, but they are fired after all initialization callbacks are called.

Remove an existing extra edge previously added by addExtraEdge.

If the implementation does not support extra edges, it will throw an error.

Sets the module info for all modules. Should only be called once.

Sets the module info for all modules. Should only be called once. Also marks modules that are currently being loaded.

Sets the batch mode as enabled or disabled for the module manager.

Sets the concurrent loading mode as enabled or disabled for the module manager. Requires a moduleloader implementation that supports concurrent loads. The default goog.module.ModuleLoader does not.

Records that the currently loading module was loaded. Also initiates loading the next module if any module requests are queued. This method is called by code that is generated and appended to each dynamic module's code at compilation time.

Sets the application-specific module loader.

Sets the constructor to use for the module object for the currently loading module. The constructor should derive from goog.module.BaseModule.

Sets the module context to use to initialize the module.

Sets the module uris.

A mapping from module id to ModuleInfo object.

A non-HTTP status code indicating a corruption in loaded module. This should be used by a ModuleLoader as a replacement for the HTTP code given to the error handler function to indicated that the module was corrupted. This will set the forceReload flag on the loadModules method when retrying module loading.

Whether subtractive module loading is enabled. The main difference is the module graph is no longer in the client, i.e., setAllModuleInfoString is never been called. Instead, the module manager will keep track of the already loaded modules, and add them to the subsequent loader requests. The serving system is able to figure out the list of desired modules.

The default is false, but new code is encouraged to use this. Search, Gmail, and many Google applications has been using subtractive module loading for years and see significantly performance benefits.