goog

Interface for goog.Dependency implementations to have some control over loading of dependencies.

When defining a class Foo with an abstract method bar(), you can do: Foo.prototype.bar = goog.abstractMethod

Now if a subclass of Foo fails to override bar(), an error will be thrown when bar() is invoked.

Adds a dependency from a file to the files it requires.

Adds a getInstance static method that always returns the same instance object.

Partially applies this function to a particular 'this object' and zero or more arguments. The result is a new function with some arguments of the first function pre-filled and the value of this 'pre-specified'.

Remaining arguments specified at call-time are appended to the pre-specified ones.

Also see: #partial.

Usage:

var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');
 barMethBound('arg3', 'arg4');

Bootstraps the given namespaces and calls the callback once they are available either via goog.require. This is a replacement for using goog.require to bootstrap Closure JavaScript. Previously a goog.require in an HTML file would guarantee that the require'd namespace was available in the next immediate script tag. With ES6 modules this no longer a guarantee.

Clones a value. The input may be an Object, Array, or basic type. Objects and arrays will be cloned recursively.

WARNINGS: goog.cloneObject does not detect reference loops. Objects that refer to themselves will cause infinite recursion.

goog.cloneObject is unaware of unique identifiers, and copies UIDs created by getUid into cloned results.

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.

Associates an ES6 module with a Closure module ID so that is available via goog.require. The associated ID acts like a goog.module ID - it does not create any global names, it is merely available via goog.require / goog.module.get / goog.forwardDeclare / goog.requireType. goog.require and goog.module.get will return the entire module as if it was import *'d. This allows Closure files to reference ES6 modules for the sake of migration.

Defines a named value. In uncompiled mode, the value is retrieved from CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and has the property specified, and otherwise used the defined defaultValue. When compiled the default can be overridden using the compiler options or the value set in the CLOSURE_DEFINES object. Returns the defined value so that it can be used safely in modules. Note that the value type MUST be either boolean, number, or string.

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).

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);

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();

Forward declares a symbol. This is an indication to the compiler that the symbol may be used in the source yet is not required and may not be provided in compilation.

The most common usage of forward declaration is code that takes a type as a function parameter but does not need to require it. By forward declaring instead of requiring, no hard dependency is made, and (if not required elsewhere) the namespace may never be required and thus, not be pulled into the JavaScript binary. If it is required elsewhere, it will be type checked as normal.

Before using goog.forwardDeclare, please read the documentation at https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to understand the options and tradeoffs when working with forward declarations.

Handles strings that are intended to be used as CSS class names.

This function works in tandem with @see goog.setCssNameMapping.

Without any mapping set, the arguments are simple joined with a hyphen and passed through unaltered.

When there is a mapping, there are two possible styles in which these mappings are used. In the BY_PART style, each part (i.e. in between hyphens) of the passed in css name is rewritten according to the map. In the BY_WHOLE style, the full css name is looked up in the map directly. If a rewrite is not specified by the map, the compiler will output a warning.

When the mapping is passed to the compiler, it will replace calls to goog.getCssName with the strings from the mapping, e.g. var x = goog.getCssName('foo'); var y = goog.getCssName(this.baseClass, 'active'); becomes: var x = 'foo'; var y = this.baseClass + '-active';

If one argument is passed it will be processed, if two are passed only the modifier will be processed, as it is assumed the first argument was generated as a result of calling goog.getCssName.

Gets a localized message.

This function is a compiler primitive. If you give the compiler a localized message bundle, it will replace the string at compile-time with a localized version, and expand goog.getMsg call to a concatenated string.

Messages must be initialized in the form: var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});

This function produces a string which should be treated as plain text. Use goog.html.SafeHtmlFormatter in conjunction with goog.getMsg to produce SafeHtml.

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.

Returns an object based on its fully qualified external name. The object is not found if null or undefined. If you are using a compilation pass that renames property names beware that using this function will not find renamed properties.

Gets a unique ID for an object. This mutates the object so that further calls with the same object as a parameter returns the same value. The unique ID is guaranteed to be unique across the current session amongst objects that are passed into getUid. There is no guarantee that the ID is unique or consistent across sessions. It is unsafe to generate unique ID for function prototypes.

Evals JavaScript in the global scope.

Throws an exception if neither execScript or eval is defined.

Whether the given object is already assigned a unique ID.

This does not modify the object.

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.
 

Returns true if the object looks like an array. To qualify as array like the value needs to be either a NodeList or an object with a Number length property. Note that for this function neither strings nor functions are considered "array-like".

Returns true if the object looks like a Date. To qualify as Date-like the value needs to be an object and have a getFullYear() function.

Returns true if the specified value is an object. This includes arrays and functions.

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.

Like goog.bind(), except that a 'this object' is not required. Useful when the target function is already bound.

Usage: var g = goog.partial(f, arg1, arg2); g(arg3, arg4);

Defines a namespace in Closure.

A namespace may only be defined once in a codebase. It may be defined using goog.provide() or goog.module().

The presence of one or more goog.provide() calls in a file indicates that the file defines the given objects/namespaces. Provided symbols must not be null or undefined.

In addition, goog.provide() creates the object stubs for a namespace (for example, goog.provide("goog.foo.bar") will create the object goog.foo.bar if it does not already exist).

Build tools also scan for provide/require/module statements to discern dependencies, build dependency files (see deps.js), etc.

Removes the unique ID from an object. This is useful if the object was previously mutated using goog.getUid in which case the mutation is undone.

Implements a system for the dynamic resolution of dependencies that works in parallel with the BUILD system.

Note that all calls to goog.require will be stripped by the compiler.

Requires a symbol for its type information. This is an indication to the compiler that the symbol may appear in type annotations, yet it is not referenced at runtime.

When called within a goog.module or ES6 module file, the return value may be assigned to or destructured into a variable, but it may not be otherwise used in code outside of a type annotation.

Note that all calls to goog.requireType will be stripped by the compiler.

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.

Sets the map to check when returning a value from goog.getCssName(). Example:

 goog.setCssNameMapping({
   "goog": "a",
   "disabled": "b",
 });

 var x = goog.getCssName('goog');
 // The following evaluates to: "a a-b".
 goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
 

When declared as a map of string literals to string literals, the JSCompiler will replace all calls to goog.getCssName() using the supplied map if the --process_closure_primitives flag is set.

Sets the dependency factory, which can be used to create custom goog.Dependency implementations to control how dependencies are loaded.

Note: if you wish to call this function and provide your own implemnetation it is a wise idea to set CLOSURE_NO_DEPS to true, otherwise the dependency file and all of its goog.addDependency calls will use the default factory. You can call goog.loadClosureDeps to load the Closure dependency file later, after your factory is injected.

Marks that the current file should only be used for testing, and never for live code in production.

In the case of unit tests, the message may optionally be an exact namespace for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra provide (if not explicitly defined in the code).

This is a "fixed" version of the typeof operator. It differs from the typeof operator in such a way that null returns 'null' and arrays return 'array'.

True if the debug loader enabled and used.

No information.

No information.

Path for included scripts.

No information.

No information.

No information.

No information.

Reference to the global object. https://www.ecma-international.org/ecma-262/9.0/index.html#sec-global-object

More info on this implementation here: https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit

No information.

No information.

No information.

No information.

No information.

No information.

No information.

No information.

No information.

No information.

No information.

No information.

No information.

No information.

If true assume that ES modules have already been transpiled by the jscompiler (in the same way that transpile.js would transpile them - to jscomp modules). Useful only for servers that wish to use the debug loader and transpile server side. Thus this is only respected if goog.TRANSPILE is "never".

If true, use the global Promise to implement run assuming either the native, or polyfill version will be used. Does still permit tests to use forceNextTick.

DEBUG is provided as a convenience so that debugging code that should not be included in a production. It can be easily stripped by specifying --define goog.DEBUG=false to the Closure Compiler aka JSCompiler. For example, most toString() methods should be declared inside an "if (goog.DEBUG)" conditional because they are generally used for debugging purposes and it is difficult for the JSCompiler to statically determine whether they are used.

Whether code that calls goog.setTestOnly should be disallowed in the compilation unit.

Whether to use a Chrome app CSP-compliant method for loading scripts via goog.require. @see appendScriptSrcNode_.

Whether to enable the debug loader.

If enabled, a call to goog.require() will attempt to load the namespace by appending a script tag to the DOM (if the namespace has been registered).

If disabled, goog.require() will simply assert that the namespace has been provided (and depend on the fact that some outside tool correctly ordered the script).

No information.

Integer year indicating the set of browser features that are guaranteed to be present. This is defined to include exactly features that work correctly on all "modern" browsers that are stable on January 1 of the specified year. For example,

if (goog.FEATURESET_YEAR >= 2019) {
  // use APIs known to be available on all major stable browsers Jan 1, 2019
} else {
  // polyfill for older browsers
}

This is intended to be the primary define for removing unnecessary browser compatibility code (such as ponyfills and workarounds), and should inform the default value for most other defines:

const ASSUME_NATIVE_PROMISE =
    goog.define('ASSUME_NATIVE_PROMISE', goog.FEATURESET_YEAR >= 2016);

The default assumption is that IE9 is the lowest supported browser, which was first available Jan 1, 2012.

TODO(user): Reference more thorough documentation when it's available.

Whether to load goog.modules using eval when using the debug loader. This provides a better debugging experience as the source is unmodified and can be edited using Chrome Workspaces or similar. However in some environments the use of eval is banned so we provide an alternative.

LOCALE defines the locale being used for compilation. It is used to select locale specific data to be compiled in js binary. BUILD rule can specify this value by "--define goog.LOCALE=<locale_name>" as a compiler option.

Take into account that the locale code format is important. You should use the canonical Unicode format with hyphen as a delimiter. Language must be lowercase, Language Script - Capitalized, Region - UPPERCASE. There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.

See more info about locale codes here: http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers

For language codes you should use values defined by ISO 693-1. See it here http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from this rule: the Hebrew language. For legacy reasons the old code (iw) should be used instead of the new code (he).

NATIVE_ARRAY_PROTOTYPES indicates whether the code should rely on Array.prototype functions, if available.

The Array.prototype functions can be defined by external libraries like Prototype and setting this flag to false forces closure to use its own goog.array implementation.

If your javascript can be loaded by a third party site and you are wary about relying on the prototype functions, specify "--define goog.NATIVE_ARRAY_PROTOTYPES=false" to the JSCompiler.

Setting goog.TRUSTED_SITE to false will automatically set NATIVE_ARRAY_PROTOTYPES to false.

Whether the exports of goog.modules should be sealed when possible.

How to decide whether to transpile. Valid values are 'always', 'never', and 'detect'. The default ('detect') is to use feature detection to determine which language levels need transpilation.

Whether this code is running on trusted sites.

On untrusted sites, several native functions can be defined or overridden by external libraries like Prototype, Datejs, and JQuery and setting this flag to false forces closure to use its own implementations when possible.

If your JavaScript can be loaded by a third party site and you are wary about relying on non-standard implementations, specify "--define goog.TRUSTED_SITE=false" to the compiler.

Trusted Types policy name. If non-empty then Closure will use Trusted Types.