=} opt_values Maps place holder name to value.
* @return {string} message with placeholders filled.
*/
goog.getMsg = function(str, opt_values) {
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=} opt_objectToExportTo The object to add the path to; default
* is goog.global.
*/
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
goog.exportPath_(publicPath, object, opt_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.
*/
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);
};
};
/**
* Call up to the superclass.
*
* If this is called from a constructor, then this calls the superclass
* constructor with arguments 1-N.
*
* If this is called from a prototype method, then you must pass the name of the
* method as the second argument to this function. If you do not, you will get a
* runtime error. This calls the superclass' method with arguments 2-N.
*
* This function only works if you use goog.inherits to express inheritance
* relationships between your classes.
*
* This function is a compiler primitive. At compile-time, the compiler will do
* macro expansion to remove a lot of the extra overhead that this function
* introduces. The compiler will also enforce a lot of the assumptions that this
* function makes, and treat it as a compiler error if you break them.
*
* @param {!Object} me Should always be "this".
* @param {*=} opt_methodName The method name if calling a super method.
* @param {...*} var_args The rest of the arguments.
* @return {*} The return value of the superclass method.
* @suppress {es5Strict} This method can not be used in strict mode, but
* all Closure Library consumers must depend on this file.
* @deprecated goog.base is not strict mode compatible. Prefer the static
* "base" method added to the constructor by goog.inherits
* or ES6 classes and the "super" keyword.
*/
goog.base = function(me, opt_methodName, var_args) {
var caller = arguments.callee.caller;
if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
throw new Error(
'arguments.caller not defined. goog.base() cannot be used ' +
'with strict mode code. See ' +
'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
}
if (typeof caller.superClass_ !== 'undefined') {
// 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 ctorArgs = new Array(arguments.length - 1);
for (var i = 1; i < arguments.length; i++) {
ctorArgs[i - 1] = arguments[i];
}
// This is a constructor. Call the superclass constructor.
return /** @type {!Function} */ (caller.superClass_)
.constructor.apply(me, ctorArgs);
}
if (typeof opt_methodName != 'string' && typeof opt_methodName != 'symbol') {
throw new Error(
'method names provided to goog.base must be a string or a symbol');
}
// 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];
}
var foundCaller = false;
for (var ctor = me.constructor; ctor;
ctor = ctor.superClass_ && ctor.superClass_.constructor) {
if (ctor.prototype[opt_methodName] === caller) {
foundCaller = true;
} else if (foundCaller) {
return ctor.prototype[opt_methodName].apply(me, args);
}
}
// If we did not find the caller in the prototype chain, then one of two
// things happened:
// 1) The caller is an instance method.
// 2) This method was not called by the right caller.
if (me[opt_methodName] === caller) {
return me.constructor.prototype[opt_methodName].apply(me, args);
} else {
throw new Error(
'goog.base called from a method of one name ' +
'to a method of a different name');
}
};
/**
* 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").
*/
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.
*/
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.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;
}
// Compute whether the constructor is sealable at definition time, rather
// than when the instance is being constructed.
var superclassSealable = !goog.defineClass.isUnsealable_(superClass);
/**
* @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_];
if (this.constructor === wrappedCtr && superclassSealable &&
Object.seal instanceof Function) {
Object.seal(instance);
}
return instance;
};
return wrappedCtr;
};
/**
* @param {Function} ctr The constructor to test.
* @return {boolean} Whether the constructor has been tagged as unsealable
* using goog.tagUnsealableClass.
* @private
*/
goog.defineClass.isUnsealable_ = function(ctr) {
return ctr && ctr.prototype &&
ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};
// 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];
}
}
};
/**
* Sealing classes breaks the older idiom of assigning properties on the
* prototype rather than in the constructor. As such, goog.defineClass
* must not seal subclasses of these old-style classes until they are fixed.
* Until then, this marks a class as "broken", instructing defineClass
* not to seal subclasses.
* @param {!Function} ctr The legacy constructor to tag as unsealable.
*/
goog.tagUnsealableClass = function(ctr) {
if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
}
};
/**
* Name for unsealable tag property.
* @const @private {string}
*/
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';
// 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 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.isDef(goog.global.CLOSURE_BASE_PATH) &&
// Anti DOM-clobbering runtime check (b/37736576).
goog.isString(goog.global.CLOSURE_BASE_PATH)) {
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.substr(l - 7, 7) == 'base.js') {
goog.basePath = src.substr(0, l - 7);
return;
}
}
};
goog.findBasePath_();
/** @struct @constructor @final */
goog.Transpiler = function() {
/** @private {?Object} */
this.requiresTranspilation_ = null;
/** @private {string} */
this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;
};
/**
* Returns a newly created map from language mode string to a boolean
* indicating whether transpilation should be done for that mode as well as
* the highest level language that this environment supports.
*
* Guaranteed invariant:
* For any two modes, l1 and l2 where l2 is a newer mode than l1,
* `map[l1] == true` implies that `map[l2] == true`.
*
* Note this method is extracted and used elsewhere, so it cannot rely on
* anything external (it should easily be able to be transformed into a
* standalone, top level function).
*
* @private
* @return {{
* target: string,
* map: !Object
* }}
*/
goog.Transpiler.prototype.createRequiresTranspilation_ = function() {
var transpilationTarget = 'es3';
var /** !Object */ requiresTranspilation = {'es3': false};
var transpilationRequiredForAllLaterModes = false;
/**
* Adds an entry to requiresTranspliation for the given language mode.
*
* IMPORTANT: Calls must be made in order from oldest to newest language
* mode.
* @param {string} modeName
* @param {function(): boolean} isSupported Returns true if the JS engine
* supports the given mode.
*/
function addNewerLanguageTranspilationCheck(modeName, isSupported) {
if (transpilationRequiredForAllLaterModes) {
requiresTranspilation[modeName] = true;
} else if (isSupported()) {
transpilationTarget = modeName;
requiresTranspilation[modeName] = false;
} else {
requiresTranspilation[modeName] = true;
transpilationRequiredForAllLaterModes = true;
}
}
/**
* Does the given code evaluate without syntax errors and return a truthy
* result?
*/
function /** boolean */ evalCheck(/** string */ code) {
try {
return !!eval(code);
} catch (ignored) {
return false;
}
}
var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
goog.global.navigator.userAgent :
'';
// Identify ES3-only browsers by their incorrect treatment of commas.
addNewerLanguageTranspilationCheck('es5', function() {
return evalCheck('[1,].length==1');
});
addNewerLanguageTranspilationCheck('es6', function() {
// Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
// https://github.com/Microsoft/ChakraCore/issues/1496.
var re = /Edge\/(\d+)(\.\d)*/i;
var edgeUserAgent = userAgent.match(re);
if (edgeUserAgent && Number(edgeUserAgent[1]) < 15) {
return false;
}
// Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
// (a) default params (specifically shadowing locals),
// (b) destructuring, (c) block-scoped functions,
// (d) for-of (const), (e) new.target/Reflect.construct
var es6fullTest =
'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
'==3}';
return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
});
// TODO(joeltine): Remove es6-impl references for b/31340605.
// Consider es6-impl (widely-implemented es6 features) to be supported
// whenever es6 is supported. Technically es6-impl is a lower level of
// support than es6, but we don't have tests specifically for it.
addNewerLanguageTranspilationCheck('es6-impl', function() {
return true;
});
// ** and **= are the only new features in 'es7'
addNewerLanguageTranspilationCheck('es7', function() {
return evalCheck('2 ** 2 == 4');
});
// async functions are the only new features in 'es8'
addNewerLanguageTranspilationCheck('es8', function() {
return evalCheck('async () => 1, true');
});
addNewerLanguageTranspilationCheck('es9', function() {
return evalCheck('({...rest} = {}), true');
});
addNewerLanguageTranspilationCheck('es_next', function() {
return false; // assume it always need to transpile
});
return {target: transpilationTarget, map: requiresTranspilation};
};
/**
* Determines whether the given language needs to be transpiled.
* @param {string} lang
* @param {string|undefined} module
* @return {boolean}
*/
goog.Transpiler.prototype.needsTranspile = function(lang, module) {
if (goog.TRANSPILE == 'always') {
return true;
} else if (goog.TRANSPILE == 'never') {
return false;
} else if (!this.requiresTranspilation_) {
var obj = this.createRequiresTranspilation_();
this.requiresTranspilation_ = obj.map;
this.transpilationTarget_ = this.transpilationTarget_ || obj.target;
}
if (lang in this.requiresTranspilation_) {
if (this.requiresTranspilation_[lang]) {
return true;
} else if (
goog.inHtmlDocument_() && module == 'es6' &&
!('noModule' in goog.global.document.createElement('script'))) {
return true;
} else {
return false;
}
} else {
throw new Error('Unknown language mode: ' + lang);
}
};
/**
* Lazily retrieves the transpiler and applies it to the source.
* @param {string} code JS code.
* @param {string} path Path to the code.
* @return {string} The transpiled code.
*/
goog.Transpiler.prototype.transpile = function(code, path) {
// TODO(johnplaisted): We should delete goog.transpile_ and just have this
// function. But there's some compile error atm where goog.global is being
// stripped incorrectly without this.
return goog.transpile_(code, path, this.transpilationTarget_);
};
/** @private @final {!goog.Transpiler} */
goog.transpiler_ = new goog.Transpiler();
/**
* 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(goog.transpiler_);
/** @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, [], [], {},
false));
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);
throw Error(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 transpiled non-goog.module files {@see goog.TranspiledDependency}.
* 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');
}
}
if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
goog.isDocumentLoading_()) {
var key = goog.Dependency.registerCallback_(function(script) {
if (!goog.DebugLoader_.IS_OLD_IE_ || script.readyState == 'complete') {
goog.Dependency.unregisterCallback_(key);
controller.loaded();
}
});
var nonceAttr = !goog.DebugLoader_.IS_OLD_IE_ && goog.getScriptNonce() ?
' nonce="' + goog.getScriptNonce() + '"' :
'';
var event =
goog.DebugLoader_.IS_OLD_IE_ ? 'onreadystatechange' : 'onload';
var defer = goog.Dependency.defer_ ? 'defer' : '';
doc.write(
'