=} opt_values Maps place holder name to value.
* @param {!goog.GetMsgOptions=} opt_options see `goog.GetMsgOptions`
* @return {string} message with placeholders filled.
*/
goog.getMsg = function(str, opt_values, opt_options) {
if (opt_options && opt_options.html) {
// Note that '&' is not replaced because the translation can contain HTML
// entities.
str = str.replace(/')
.replace(/'/g, '\'')
.replace(/"/g, '"')
.replace(/&/g, '&');
}
if (opt_values) {
str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
return (opt_values != null && key in opt_values) ? opt_values[key] :
match;
});
}
return str;
};
/**
* Gets a localized message. If the message does not have a translation, gives a
* fallback message.
*
* This is useful when introducing a new message that has not yet been
* translated into all languages.
*
* This function is a compiler primitive. Must be used in the form:
* var x = goog.getMsgWithFallback(MSG_A, MSG_B);
* where MSG_A and MSG_B were initialized with goog.getMsg.
*
* @param {string} a The preferred message.
* @param {string} b The fallback message.
* @return {string} The best translated message.
*/
goog.getMsgWithFallback = function(a, b) {
return a;
};
/**
* Exposes an unobfuscated global namespace path for the given object.
* Note that fields of the exported object *will* be obfuscated, unless they are
* exported in turn via this function or goog.exportProperty.
*
* Also handy for making public items that are defined in anonymous closures.
*
* ex. goog.exportSymbol('public.path.Foo', Foo);
*
* ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
* public.path.Foo.staticFunction();
*
* ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
* Foo.prototype.myMethod);
* new public.path.Foo().myMethod();
*
* @param {string} publicPath Unobfuscated name to export.
* @param {*} object Object the name should point to.
* @param {?Object=} objectToExportTo The object to add the path to; default
* is goog.global.
*/
goog.exportSymbol = function(publicPath, object, objectToExportTo) {
goog.exportPath_(
publicPath, object, /* overwriteImplicit= */ true, objectToExportTo);
};
/**
* Exports a property unobfuscated into the object's namespace.
* ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
* ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
* @param {Object} object Object whose static property is being exported.
* @param {string} publicName Unobfuscated name to export.
* @param {*} symbol Object the name should point to.
*/
goog.exportProperty = function(object, publicName, symbol) {
object[publicName] = symbol;
};
/**
* Inherit the prototype methods from one constructor into another.
*
* Usage:
*
* function ParentClass(a, b) { }
* ParentClass.prototype.foo = function(a) { };
*
* function ChildClass(a, b, c) {
* ChildClass.base(this, 'constructor', a, b);
* }
* goog.inherits(ChildClass, ParentClass);
*
* var child = new ChildClass('a', 'b', 'see');
* child.foo(); // This works.
*
*
* @param {!Function} childCtor Child class.
* @param {!Function} parentCtor Parent class.
* @suppress {strictMissingProperties} superClass_ and base is not defined on
* Function.
* @deprecated Use ECMAScript class syntax instead.
*/
goog.inherits = function(childCtor, parentCtor) {
/** @constructor */
function tempCtor() {}
tempCtor.prototype = parentCtor.prototype;
childCtor.superClass_ = parentCtor.prototype;
childCtor.prototype = new tempCtor();
/** @override */
childCtor.prototype.constructor = childCtor;
/**
* Calls superclass constructor/method.
*
* This function is only available if you use goog.inherits to
* express inheritance relationships between classes.
*
* NOTE: This is a replacement for goog.base and for superClass_
* property defined in childCtor.
*
* @param {!Object} me Should always be "this".
* @param {string} methodName The method name to call. Calling
* superclass constructor can be done with the special string
* 'constructor'.
* @param {...*} var_args The arguments to pass to superclass
* method/constructor.
* @return {*} The return value of the superclass method/constructor.
*/
childCtor.base = function(me, methodName, var_args) {
// Copying using loop to avoid deop due to passing arguments object to
// function. This is faster in many JS engines as of late 2014.
var args = new Array(arguments.length - 2);
for (var i = 2; i < arguments.length; i++) {
args[i - 2] = arguments[i];
}
return parentCtor.prototype[methodName].apply(me, args);
};
};
/**
* Allow for aliasing within scope functions. This function exists for
* uncompiled code - in compiled code the calls will be inlined and the aliases
* applied. In uncompiled code the function is simply run since the aliases as
* written are valid JavaScript.
*
*
* @param {function()} fn Function to call. This function can contain aliases
* to namespaces (e.g. "var dom = goog.dom") or classes
* (e.g. "var Timer = goog.Timer").
* @deprecated Use goog.module instead.
*/
goog.scope = function(fn) {
if (goog.isInModuleLoader_()) {
throw new Error('goog.scope is not supported within a module.');
}
fn.call(goog.global);
};
/*
* To support uncompiled, strict mode bundles that use eval to divide source
* like so:
* eval('someSource;//# sourceUrl sourcefile.js');
* We need to export the globally defined symbols "goog" and "COMPILED".
* Exporting "goog" breaks the compiler optimizations, so we required that
* be defined externally.
* NOTE: We don't use goog.exportSymbol here because we don't want to trigger
* extern generation when that compiler option is enabled.
*/
if (!COMPILED) {
goog.global['COMPILED'] = COMPILED;
}
//==============================================================================
// goog.defineClass implementation
//==============================================================================
/**
* Creates a restricted form of a Closure "class":
* - from the compiler's perspective, the instance returned from the
* constructor is sealed (no new properties may be added). This enables
* better checks.
* - the compiler will rewrite this definition to a form that is optimal
* for type checking and optimization (initially this will be a more
* traditional form).
*
* @param {Function} superClass The superclass, Object or null.
* @param {goog.defineClass.ClassDescriptor} def
* An object literal describing
* the class. It may have the following properties:
* "constructor": the constructor function
* "statics": an object literal containing methods to add to the constructor
* as "static" methods or a function that will receive the constructor
* function as its only parameter to which static properties can
* be added.
* all other properties are added to the prototype.
* @return {!Function} The class constructor.
* @deprecated Use ECMAScript class syntax instead.
*/
goog.defineClass = function(superClass, def) {
// TODO(johnlenz): consider making the superClass an optional parameter.
var constructor = def.constructor;
var statics = def.statics;
// Wrap the constructor prior to setting up the prototype and static methods.
if (!constructor || constructor == Object.prototype.constructor) {
constructor = function() {
throw new Error(
'cannot instantiate an interface (no constructor defined).');
};
}
var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
if (superClass) {
goog.inherits(cls, superClass);
}
// Remove all the properties that should not be copied to the prototype.
delete def.constructor;
delete def.statics;
goog.defineClass.applyProperties_(cls.prototype, def);
if (statics != null) {
if (statics instanceof Function) {
statics(cls);
} else {
goog.defineClass.applyProperties_(cls, statics);
}
}
return cls;
};
/**
* @typedef {{
* constructor: (!Function|undefined),
* statics: (Object|undefined|function(Function):void)
* }}
*/
goog.defineClass.ClassDescriptor;
/**
* @define {boolean} Whether the instances returned by goog.defineClass should
* be sealed when possible.
*
* When sealing is disabled the constructor function will not be wrapped by
* goog.defineClass, making it incompatible with ES6 class methods.
*/
goog.defineClass.SEAL_CLASS_INSTANCES =
goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);
/**
* If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
* defined, this function will wrap the constructor in a function that seals the
* results of the provided constructor function.
*
* @param {!Function} ctr The constructor whose results maybe be sealed.
* @param {Function} superClass The superclass constructor.
* @return {!Function} The replacement constructor.
* @private
*/
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
// Do now wrap the constructor when sealing is disabled. Angular code
// depends on this for injection to work properly.
return ctr;
}
// NOTE: The sealing behavior has been removed
/**
* @this {Object}
* @return {?}
*/
var wrappedCtr = function() {
// Don't seal an instance of a subclass when it calls the constructor of
// its super class as there is most likely still setup to do.
var instance = ctr.apply(this, arguments) || this;
instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
return instance;
};
return wrappedCtr;
};
// TODO(johnlenz): share these values with the goog.object
/**
* The names of the fields that are defined on Object.prototype.
* @type {!Array}
* @private
* @const
*/
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
'toLocaleString', 'toString', 'valueOf'
];
// TODO(johnlenz): share this function with the goog.object
/**
* @param {!Object} target The object to add properties to.
* @param {!Object} source The object to copy properties from.
* @private
*/
goog.defineClass.applyProperties_ = function(target, source) {
// TODO(johnlenz): update this to support ES5 getters/setters
var key;
for (key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
// For IE the for-in-loop does not contain any properties that are not
// enumerable on the prototype object (for example isPrototypeOf from
// Object.prototype) and it will also not include 'replace' on objects that
// extend String and change 'replace' (not that it is common for anyone to
// extend anything except Object).
for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
};
/**
* Returns the parameter.
* @param {string} s
* @return {string}
* @private
*/
goog.identity_ = function(s) {
return s;
};
/**
* Creates Trusted Types policy if Trusted Types are supported by the browser.
* The policy just blesses any string as a Trusted Type. It is not visibility
* restricted because anyone can also call trustedTypes.createPolicy directly.
* However, the allowed names should be restricted by a HTTP header and the
* reference to the created policy should be visibility restricted.
* @param {string} name
* @return {?TrustedTypePolicy}
*/
goog.createTrustedTypesPolicy = function(name) {
var policy = null;
var policyFactory = goog.global.trustedTypes;
if (!policyFactory || !policyFactory.createPolicy) {
return policy;
}
// trustedTypes.createPolicy throws if called with a name that is already
// registered, even in report-only mode. Until the API changes, catch the
// error not to break the applications functionally. In such case, the code
// will fall back to using regular Safe Types.
// TODO(koto): Remove catching once createPolicy API stops throwing.
try {
policy = policyFactory.createPolicy(name, {
createHTML: goog.identity_,
createScript: goog.identity_,
createScriptURL: goog.identity_
});
} catch (e) {
goog.logToConsole_(e.message);
}
return policy;
};
// There's a bug in the compiler where without collapse properties the
// Closure namespace defines do not guard code correctly. To help reduce code
// size also check for !COMPILED even though it redundant until this is fixed.
if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
/**
* Tries to detect whether the current browser is Edge, based on the user
* agent. This matches only pre-Chromium Edge.
* @see https://docs.microsoft.com/en-us/microsoft-edge/web-platform/user-agent-string
* @return {boolean} True if the current browser is Edge.
* @private
*/
goog.isEdge_ = function() {
var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
goog.global.navigator.userAgent :
'';
var edgeRe = /Edge\/(\d+)(\.\d)*/i;
return !!userAgent.match(edgeRe);
};
/**
* Tries to detect whether is in the context of an HTML document.
* @return {boolean} True if it looks like HTML document.
* @private
*/
goog.inHtmlDocument_ = function() {
/** @type {!Document} */
var doc = goog.global.document;
return doc != null && 'write' in doc; // XULDocument misses write.
};
/**
* We'd like to check for if the document readyState is 'loading'; however
* there are bugs on IE 10 and below where the readyState being anything other
* than 'complete' is not reliable.
* @return {boolean}
* @private
*/
goog.isDocumentLoading_ = function() {
// attachEvent is available on IE 6 thru 10 only, and thus can be used to
// detect those browsers.
/** @type {!HTMLDocument} */
var doc = goog.global.document;
return doc.attachEvent ? doc.readyState != 'complete' :
doc.readyState == 'loading';
};
/**
* Tries to detect the base path of base.js script that bootstraps Closure.
* @private
*/
goog.findBasePath_ = function() {
if (goog.global.CLOSURE_BASE_PATH != undefined &&
// Anti DOM-clobbering runtime check (b/37736576).
typeof goog.global.CLOSURE_BASE_PATH === 'string') {
goog.basePath = goog.global.CLOSURE_BASE_PATH;
return;
} else if (!goog.inHtmlDocument_()) {
return;
}
/** @type {!Document} */
var doc = goog.global.document;
// If we have a currentScript available, use it exclusively.
var currentScript = doc.currentScript;
if (currentScript) {
var scripts = [currentScript];
} else {
var scripts = doc.getElementsByTagName('SCRIPT');
}
// Search backwards since the current script is in almost all cases the one
// that has base.js.
for (var i = scripts.length - 1; i >= 0; --i) {
var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
var src = script.src;
var qmark = src.lastIndexOf('?');
var l = qmark == -1 ? src.length : qmark;
if (src.slice(l - 7, l) == 'base.js') {
goog.basePath = src.slice(0, l - 7);
return;
}
}
};
goog.findBasePath_();
/**
* Rewrites closing script tags in input to avoid ending an enclosing script
* tag.
*
* @param {string} str
* @return {string}
* @private
*/
goog.protectScriptTag_ = function(str) {
return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
};
/**
* A debug loader is responsible for downloading and executing javascript
* files in an unbundled, uncompiled environment.
*
* This can be custimized via the setDependencyFactory method, or by
* CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.
*
* @struct @constructor @final @private
*/
goog.DebugLoader_ = function() {
/** @private @const {!Object} */
this.dependencies_ = {};
/** @private @const {!Object} */
this.idToPath_ = {};
/** @private @const {!Object} */
this.written_ = {};
/** @private @const {!Array} */
this.loadingDeps_ = [];
/** @private {!Array} */
this.depsToLoad_ = [];
/** @private {boolean} */
this.paused_ = false;
/** @private {!goog.DependencyFactory} */
this.factory_ = new goog.DependencyFactory();
/** @private @const {!Object} */
this.deferredCallbacks_ = {};
/** @private @const {!Array} */
this.deferredQueue_ = [];
};
/**
* @param {!Array} namespaces
* @param {function(): undefined} callback Function to call once all the
* namespaces have loaded.
*/
goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
var cb = callback;
function resolve() {
if (cb) {
goog.global.setTimeout(cb, 0);
cb = null;
}
}
if (!namespaces.length) {
resolve();
return;
}
var deps = [];
for (var i = 0; i < namespaces.length; i++) {
var path = this.getPathFromDeps_(namespaces[i]);
if (!path) {
throw new Error('Unregonized namespace: ' + namespaces[i]);
}
deps.push(this.dependencies_[path]);
}
var require = goog.require;
var loaded = 0;
for (var i = 0; i < namespaces.length; i++) {
require(namespaces[i]);
deps[i].onLoad(function() {
if (++loaded == namespaces.length) {
resolve();
}
});
}
};
/**
* Loads the Closure Dependency file.
*
* Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
* loaded, setDependencyFactory called, and then this called. i.e. allows
* custom loading of the deps file.
*/
goog.DebugLoader_.prototype.loadClosureDeps = function() {
// Circumvent addDependency, which would try to transpile deps.js if
// transpile is set to always.
var relPath = 'deps.js';
this.depsToLoad_.push(this.factory_.createDependency(
goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}));
this.loadDeps_();
};
/**
* Notifies the debug loader when a dependency has been requested.
*
* @param {string} absPathOrId Path of the dependency or goog id.
* @param {boolean=} opt_force
*/
goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
var path = this.getPathFromDeps_(absPathOrId);
if (path &&
(opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
var callback = this.deferredCallbacks_[path];
if (callback) {
delete this.deferredCallbacks_[path];
callback();
}
}
};
/**
* Sets the dependency factory, which can be used to create custom
* goog.Dependency implementations to control how dependencies are loaded.
*
* @param {!goog.DependencyFactory} factory
*/
goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
this.factory_ = factory;
};
/**
* Travserses the dependency graph and queues the given dependency, and all of
* its transitive dependencies, for loading and then starts loading if not
* paused.
*
* @param {string} namespace
* @private
*/
goog.DebugLoader_.prototype.load_ = function(namespace) {
if (!this.getPathFromDeps_(namespace)) {
var errorMessage = 'goog.require could not find: ' + namespace;
goog.logToConsole_(errorMessage);
} else {
var loader = this;
var deps = [];
/** @param {string} namespace */
var visit = function(namespace) {
var path = loader.getPathFromDeps_(namespace);
if (!path) {
throw new Error('Bad dependency path or symbol: ' + namespace);
}
if (loader.written_[path]) {
return;
}
loader.written_[path] = true;
var dep = loader.dependencies_[path];
for (var i = 0; i < dep.requires.length; i++) {
if (!goog.isProvided_(dep.requires[i])) {
visit(dep.requires[i]);
}
}
deps.push(dep);
};
visit(namespace);
var wasLoading = !!this.depsToLoad_.length;
this.depsToLoad_ = this.depsToLoad_.concat(deps);
if (!this.paused_ && !wasLoading) {
this.loadDeps_();
}
}
};
/**
* Loads any queued dependencies until they are all loaded or paused.
*
* @private
*/
goog.DebugLoader_.prototype.loadDeps_ = function() {
var loader = this;
var paused = this.paused_;
while (this.depsToLoad_.length && !paused) {
(function() {
var loadCallDone = false;
var dep = loader.depsToLoad_.shift();
var loaded = false;
loader.loading_(dep);
var controller = {
pause: function() {
if (loadCallDone) {
throw new Error('Cannot call pause after the call to load.');
} else {
paused = true;
}
},
resume: function() {
if (loadCallDone) {
loader.resume_();
} else {
// Some dep called pause and then resume in the same load call.
// Just keep running this same loop.
paused = false;
}
},
loaded: function() {
if (loaded) {
throw new Error('Double call to loaded.');
}
loaded = true;
loader.loaded_(dep);
},
pending: function() {
// Defensive copy.
var pending = [];
for (var i = 0; i < loader.loadingDeps_.length; i++) {
pending.push(loader.loadingDeps_[i]);
}
return pending;
},
/**
* @param {goog.ModuleType} type
*/
setModuleState: function(type) {
goog.moduleLoaderState_ = {
type: type,
moduleName: '',
declareLegacyNamespace: false
};
},
/** @type {function(string, string, string=)} */
registerEs6ModuleExports: function(
path, exports, opt_closureNamespace) {
if (opt_closureNamespace) {
goog.loadedModules_[opt_closureNamespace] = {
exports: exports,
type: goog.ModuleType.ES6,
moduleId: opt_closureNamespace || ''
};
}
},
/** @type {function(string, ?)} */
registerGoogModuleExports: function(moduleId, exports) {
goog.loadedModules_[moduleId] = {
exports: exports,
type: goog.ModuleType.GOOG,
moduleId: moduleId
};
},
clearModuleState: function() {
goog.moduleLoaderState_ = null;
},
defer: function(callback) {
if (loadCallDone) {
throw new Error(
'Cannot register with defer after the call to load.');
}
loader.defer_(dep, callback);
},
areDepsLoaded: function() {
return loader.areDepsLoaded_(dep.requires);
}
};
try {
dep.load(controller);
} finally {
loadCallDone = true;
}
})();
}
if (paused) {
this.pause_();
}
};
/** @private */
goog.DebugLoader_.prototype.pause_ = function() {
this.paused_ = true;
};
/** @private */
goog.DebugLoader_.prototype.resume_ = function() {
if (this.paused_) {
this.paused_ = false;
this.loadDeps_();
}
};
/**
* Marks the given dependency as loading (load has been called but it has not
* yet marked itself as finished). Useful for dependencies that want to know
* what else is loading. Example: goog.modules cannot eval if there are
* loading dependencies.
*
* @param {!goog.Dependency} dep
* @private
*/
goog.DebugLoader_.prototype.loading_ = function(dep) {
this.loadingDeps_.push(dep);
};
/**
* Marks the given dependency as having finished loading and being available
* for require.
*
* @param {!goog.Dependency} dep
* @private
*/
goog.DebugLoader_.prototype.loaded_ = function(dep) {
for (var i = 0; i < this.loadingDeps_.length; i++) {
if (this.loadingDeps_[i] == dep) {
this.loadingDeps_.splice(i, 1);
break;
}
}
for (var i = 0; i < this.deferredQueue_.length; i++) {
if (this.deferredQueue_[i] == dep.path) {
this.deferredQueue_.splice(i, 1);
break;
}
}
if (this.loadingDeps_.length == this.deferredQueue_.length &&
!this.depsToLoad_.length) {
// Something has asked to load these, but they may not be directly
// required again later, so load them now that we know we're done loading
// everything else. e.g. a goog module entry point.
while (this.deferredQueue_.length) {
this.requested(this.deferredQueue_.shift(), true);
}
}
dep.loaded();
};
/**
* @param {!Array} pathsOrIds
* @return {boolean}
* @private
*/
goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
for (var i = 0; i < pathsOrIds.length; i++) {
var path = this.getPathFromDeps_(pathsOrIds[i]);
if (!path ||
(!(path in this.deferredCallbacks_) &&
!goog.isProvided_(pathsOrIds[i]))) {
return false;
}
}
return true;
};
/**
* @param {string} absPathOrId
* @return {?string}
* @private
*/
goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
if (absPathOrId in this.idToPath_) {
return this.idToPath_[absPathOrId];
} else if (absPathOrId in this.dependencies_) {
return absPathOrId;
} else {
return null;
}
};
/**
* @param {!goog.Dependency} dependency
* @param {!Function} callback
* @private
*/
goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
this.deferredCallbacks_[dependency.path] = callback;
this.deferredQueue_.push(dependency.path);
};
/**
* Interface for goog.Dependency implementations to have some control over
* loading of dependencies.
*
* @record
*/
goog.LoadController = function() {};
/**
* Tells the controller to halt loading of more dependencies.
*/
goog.LoadController.prototype.pause = function() {};
/**
* Tells the controller to resume loading of more dependencies if paused.
*/
goog.LoadController.prototype.resume = function() {};
/**
* Tells the controller that this dependency has finished loading.
*
* This causes this to be removed from pending() and any load callbacks to
* fire.
*/
goog.LoadController.prototype.loaded = function() {};
/**
* List of dependencies on which load has been called but which have not
* called loaded on their controller. This includes the current dependency.
*
* @return {!Array}
*/
goog.LoadController.prototype.pending = function() {};
/**
* Registers an object as an ES6 module's exports so that goog.modules may
* require it by path.
*
* @param {string} path Full path of the module.
* @param {?} exports
* @param {string=} opt_closureNamespace Closure namespace to associate with
* this module.
*/
goog.LoadController.prototype.registerEs6ModuleExports = function(
path, exports, opt_closureNamespace) {};
/**
* Sets the current module state.
*
* @param {goog.ModuleType} type Type of module.
*/
goog.LoadController.prototype.setModuleState = function(type) {};
/**
* Clears the current module state.
*/
goog.LoadController.prototype.clearModuleState = function() {};
/**
* Registers a callback to call once the dependency is actually requested
* via goog.require + all of the immediate dependencies have been loaded or
* all other files have been loaded. Allows for lazy loading until
* require'd without pausing dependency loading, which is needed on old IE.
*
* @param {!Function} callback
*/
goog.LoadController.prototype.defer = function(callback) {};
/**
* @return {boolean}
*/
goog.LoadController.prototype.areDepsLoaded = function() {};
/**
* Basic super class for all dependencies Closure Library can load.
*
* This default implementation is designed to load untranspiled, non-module
* scripts in a web broswer.
*
* For goog.modules see {@see goog.GoogModuleDependency}.
* For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.
*
* @param {string} path Absolute path of this script.
* @param {string} relativePath Path of this script relative to goog.basePath.
* @param {!Array} provides goog.provided or goog.module symbols
* in this file.
* @param {!Array} requires goog symbols or relative paths to Closure
* this depends on.
* @param {!Object} loadFlags
* @struct @constructor
*/
goog.Dependency = function(
path, relativePath, provides, requires, loadFlags) {
/** @const */
this.path = path;
/** @const */
this.relativePath = relativePath;
/** @const */
this.provides = provides;
/** @const */
this.requires = requires;
/** @const */
this.loadFlags = loadFlags;
/** @private {boolean} */
this.loaded_ = false;
/** @private {!Array} */
this.loadCallbacks_ = [];
};
/**
* @return {string} The pathname part of this dependency's path if it is a
* URI.
*/
goog.Dependency.prototype.getPathName = function() {
var pathName = this.path;
var protocolIndex = pathName.indexOf('://');
if (protocolIndex >= 0) {
pathName = pathName.substring(protocolIndex + 3);
var slashIndex = pathName.indexOf('/');
if (slashIndex >= 0) {
pathName = pathName.substring(slashIndex + 1);
}
}
return pathName;
};
/**
* @param {function()} callback Callback to fire as soon as this has loaded.
* @final
*/
goog.Dependency.prototype.onLoad = function(callback) {
if (this.loaded_) {
callback();
} else {
this.loadCallbacks_.push(callback);
}
};
/**
* Marks this dependency as loaded and fires any callbacks registered with
* onLoad.
* @final
*/
goog.Dependency.prototype.loaded = function() {
this.loaded_ = true;
var callbacks = this.loadCallbacks_;
this.loadCallbacks_ = [];
for (var i = 0; i < callbacks.length; i++) {
callbacks[i]();
}
};
/**
* Whether or not document.written / appended script tags should be deferred.
*
* @private {boolean}
*/
goog.Dependency.defer_ = false;
/**
* Map of script ready / state change callbacks. Old IE cannot handle putting
* these properties on goog.global.
*
* @private @const {!Object}
*/
goog.Dependency.callbackMap_ = {};
/**
* @param {function(...?):?} callback
* @return {string}
* @private
*/
goog.Dependency.registerCallback_ = function(callback) {
var key = Math.random().toString(32);
goog.Dependency.callbackMap_[key] = callback;
return key;
};
/**
* @param {string} key
* @private
*/
goog.Dependency.unregisterCallback_ = function(key) {
delete goog.Dependency.callbackMap_[key];
};
/**
* @param {string} key
* @param {...?} var_args
* @private
* @suppress {unusedPrivateMembers}
*/
goog.Dependency.callback_ = function(key, var_args) {
if (key in goog.Dependency.callbackMap_) {
var callback = goog.Dependency.callbackMap_[key];
var args = [];
for (var i = 1; i < arguments.length; i++) {
args.push(arguments[i]);
}
callback.apply(undefined, args);
} else {
var errorMessage = 'Callback key ' + key +
' does not exist (was base.js loaded more than once?).';
throw Error(errorMessage);
}
};
/**
* Starts loading this dependency. This dependency can pause loading if it
* needs to and resume it later via the controller interface.
*
* When this is loaded it should call controller.loaded(). Note that this will
* end up calling the loaded method of this dependency; there is no need to
* call it explicitly.
*
* @param {!goog.LoadController} controller
*/
goog.Dependency.prototype.load = function(controller) {
if (goog.global.CLOSURE_IMPORT_SCRIPT) {
if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
controller.loaded();
} else {
controller.pause();
}
return;
}
if (!goog.inHtmlDocument_()) {
goog.logToConsole_(
'Cannot use default debug loader outside of HTML documents.');
if (this.relativePath == 'deps.js') {
// Some old code is relying on base.js auto loading deps.js failing with
// no error before later setting CLOSURE_IMPORT_SCRIPT.
// CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or
// CLOSURE_NO_DEPS set to true.
goog.logToConsole_(
'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +
'or setting CLOSURE_NO_DEPS to true.');
controller.loaded();
} else {
controller.pause();
}
return;
}
/** @type {!HTMLDocument} */
var doc = goog.global.document;
// If the user tries to require a new symbol after document load,
// something has gone terribly wrong. Doing a document.write would
// wipe out the page. This does not apply to the CSP-compliant method
// of writing script tags.
if (doc.readyState == 'complete' &&
!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
// Certain test frameworks load base.js multiple times, which tries
// to write deps.js each time. If that happens, just fail silently.
// These frameworks wipe the page between each load of base.js, so this
// is OK.
var isDeps = /\bdeps.js$/.test(this.path);
if (isDeps) {
controller.loaded();
return;
} else {
throw Error('Cannot write "' + this.path + '" after document load');
}
}
var nonce = goog.getScriptNonce_();
if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
goog.isDocumentLoading_()) {
var key;
var callback = function(script) {
if (script.readyState && script.readyState != 'complete') {
script.onload = callback;
return;
}
goog.Dependency.unregisterCallback_(key);
controller.loaded();
};
key = goog.Dependency.registerCallback_(callback);
var defer = goog.Dependency.defer_ ? ' defer' : '';
var nonceAttr = nonce ? ' nonce="' + nonce + '"' : '';
var script = '