Class goog.module.ModuleManager

Loads a single module for use with a given deferred.

Ensures that the module with the given id is listed as a user-initiated module that is being loaded. This method guarantees that a module will never get listed more than once.

Method called just after module code is loaded

Method called just before a module code is loaded.

Dispatches an ACTIVE or IDLE event if necessary.

Handles when a module load failed.

Deletes or nulls out any references to COM objects, DOM nodes, or other disposable objects. Classes that extend {@code goog.Disposable} should override this method. Not reentrant. To avoid calling it twice, it must only be called from the subclass' {@code disposeInternal} method. Everywhere else the public {@code dispose} method must be used. For example:

mypackage.MyClass = function() {
goog.base(this);
// Constructor logic specific to MyClass.
...
};
goog.inherits(mypackage.MyClass, goog.Disposable);

mypackage.MyClass.prototype.disposeInternal = function() {
goog.base(this, 'disposeInternal');
// Dispose logic specific to MyClass.
...
};

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.

Call the callback functions of the specified type.

Gets the amount of delay to wait before sending a request for more modules. If a certain module request fails, we backoff a little bit and try again.

Gets the application-specific module loader.

Gets the module context to use to initialize the module.

Gets a module info object by id.

Builds a list of the ids of the not-yet-loaded modules that a particular module transitively depends on, including itself.

Handles a module load failure.

Handles a module load timeout.

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 a goog.async.Deferred for keeping track of the result.

Loads a list of modules or, if some other module is currently being loaded, appends the ids to the queue of requested module ids. Does nothing if the module is already loaded or is currently loading.

Initiates loading of a list of modules or, if a module is currently being loaded, appends the modules to the queue of requested module ids. The caller should verify that the requested modules are not already loaded or loading. {@link #loadModulesOrEnqueueIfNotLoadedOrLoading_} is a more lenient alternative to this method.

Loads a list of modules and any of their not-yet-loaded prerequisites. If batch mode is enabled, the prerequisites will be loaded together with the requested modules and all requested modules will be loaded at the same time. The caller should verify that the requested modules are not already loaded and that no modules are currently loading before calling this method.

Loads a list of modules, returning a goog.async.Deferred for keeping track of the result.

Loads the next modules on the queue.

If we are still loading the base module, consider the load complete.

Preloads a module after a short delay.

Processes a list of module ids for loading. Checks if any of the modules are already loaded and then gets transitive deps. Queues any necessary modules if batch mode is not enabled. Returns the list of ids that should be loaded.

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

Register a callback for the specified callback type.

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.

Registers the callbacks and handles logic if it is a user initiated module load.

Requeues batch loads that had more than one requested module (i.e. modules that were not included as dependencies) as separate loads or if there was only one requested module, fails that module with the received cause.

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.

Records that a 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 {@see goog.module.BaseModule}.

Sets the module context to use to initialize the module.

Sets the module uris.