static-injector 2.0.0 → 2.1.1

package/import/es2015/di/r3_injector.js

@@ -5,20 +5,23 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import { RuntimeError } from '../errors';
 import { getFactoryDef } from '../render3/definition_factory';
 import { newArray } from '../util/array_utils';
 import { EMPTY_ARRAY } from '../util/empty';
 import { stringify } from '../util/stringify';
 import { resolveForwardRef } from './forward_ref';
 import { ENVIRONMENT_INITIALIZER } from './initializer_token';
+import { setInjectImplementation } from './inject_switch';
 import { InjectionToken } from './injection_token';
-import { catchInjectorError, convertToBitFlags, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, USE_VALUE, ɵɵinject, } from './injector_compatibility';
+import { catchInjectorError, convertToBitFlags, injectArgs, NG_TEMP_TOKEN_PATH, setCurrentInjector, THROW_IF_NOT_FOUND, ɵɵinject, } from './injector_compatibility';
 import { INJECTOR } from './injector_token';
-import { setInjectImplementation } from './inject_switch';
 import { getInheritedInjectableDef, getInjectableDef, } from './interface/defs';
 import { InjectFlags } from './interface/injector';
+import { isEnvironmentProviders, } from './interface/provider';
 import { INJECTOR_DEF_TYPES } from './internal_tokens';
 import { NullInjector } from './null_injector';
+import { isExistingProvider, isFactoryProvider, isTypeProvider, isValueProvider, } from './provider_collection';
 import { INJECTOR_SCOPE } from './scope';
 /**
  * Marker which indicates that a value has not yet been created from the factory function.
@@ -49,6 +52,12 @@ export function getNullInjector() {
 export class EnvironmentInjector {
 }
 export class R3Injector extends EnvironmentInjector {
+    /**
+     * Flag indicating that this injector was previously destroyed.
+     */
+    get destroyed() {
+        return this._destroyed;
+    }
     constructor(providers, parent, source, scopes) {
         super();
         this.parent = parent;
@@ -82,12 +91,6 @@ export class R3Injector extends EnvironmentInjector {
         }
         this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES.multi, EMPTY_ARRAY, InjectFlags.Self));
     }
-    /**
-     * Flag indicating that this injector was previously destroyed.
-     */
-    get destroyed() {
-        return this._destroyed;
-    }
     /**
      * Destroy the injector and release references to every instance or provider associated with it.
      *
@@ -203,6 +206,8 @@ export class R3Injector extends EnvironmentInjector {
         const previousInjectImplementation = setInjectImplementation(undefined);
         try {
             const initializers = this.get(ENVIRONMENT_INITIALIZER.multi, EMPTY_ARRAY, InjectFlags.Self);
+            if (false) {
+            }
             for (const initializer of initializers) {
                 initializer();
             }
@@ -222,7 +227,7 @@ export class R3Injector extends EnvironmentInjector {
     }
     assertNotDestroyed() {
         if (this._destroyed) {
-            throw new Error('Injector has already been destroyed.');
+            throw new RuntimeError(205 /* RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED */, null);
         }
     }
     /**
@@ -243,6 +248,8 @@ export class R3Injector extends EnvironmentInjector {
             let multiRecord = this.records.get(token);
             if (multiRecord) {
                 // It has. Throw a nice error if
+                if (false) {
+                }
             }
             else {
                 multiRecord = makeRecord(undefined, NOT_YET, true);
@@ -254,11 +261,15 @@ export class R3Injector extends EnvironmentInjector {
         }
         else {
             const existing = this.records.get(token);
+            if (false) {
+            }
         }
         this.records.set(token, record);
     }
     hydrate(token, record) {
-        if (record.value === NOT_YET) {
+        if (false) {
+        }
+        else if (record.value === NOT_YET) {
             record.value = CIRCULAR;
             record.value = record.factory();
         }
@@ -292,21 +303,21 @@ function injectableDefOrInjectorDefFactory(token) {
     // InjectionTokens should have an injectable def (ɵprov) and thus should be handled above.
     // If it's missing that, it's an error.
     if (token instanceof InjectionToken) {
-        throw new Error(`Token ${stringify(token)} is missing a ɵprov definition.`);
+        throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, null);
     }
     // Undecorated types can sometimes be created if they have no constructor arguments.
     if (token instanceof Function) {
         return getUndecoratedInjectableFactory(token);
     }
     // There was no way to resolve a factory for this token.
-    throw new Error('unreachable');
+    throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, null);
 }
 function getUndecoratedInjectableFactory(token) {
     // If the token has parameters then it has dependencies that we cannot resolve implicitly.
     const paramLength = token.length;
     if (paramLength > 0) {
         const args = newArray(paramLength, '?');
-        throw new Error(`Can't resolve all parameters for ${stringify(token)}: (${args.join(', ')}).`);
+        throw new RuntimeError(204 /* RuntimeErrorCode.INVALID_INJECTION_TOKEN */, null);
     }
     // The constructor function appears to have no parameters.
     // This might be because it inherits from a super-class. In which case, use an injectable
@@ -337,6 +348,8 @@ function providerToRecord(provider) {
  */
 export function providerToFactory(provider, ngModuleType, providers) {
     let factory = undefined;
+    if (false) {
+    }
     if (isTypeProvider(provider)) {
         const unwrappedProvider = resolveForwardRef(provider);
         return (getFactoryDef(unwrappedProvider) ||
@@ -356,9 +369,8 @@ export function providerToFactory(provider, ngModuleType, providers) {
             const classRef = resolveForwardRef(provider &&
                 (provider.useClass ||
                     provider.provide));
-            // if (ngDevMode && !classRef) {
-            //   throwInvalidProviderError(ngModuleType, providers, provider);
-            // }
+            if (false) {
+            }
             if (hasDeps(provider)) {
                 factory = () => new classRef(...injectArgs(provider.deps));
             }
@@ -376,18 +388,6 @@ function makeRecord(factory, value, multi = false) {
         multi: multi ? [] : undefined,
     };
 }
-function isValueProvider(value) {
-    return value !== null && typeof value == 'object' && USE_VALUE in value;
-}
-function isExistingProvider(value) {
-    return !!(value && value.useExisting);
-}
-function isFactoryProvider(value) {
-    return !!(value && value.useFactory);
-}
-export function isTypeProvider(value) {
-    return typeof value === 'function';
-}
 function hasDeps(value) {
     return !!value.deps;
 }
@@ -405,6 +405,9 @@ function forEachSingleProvider(providers, fn) {
         if (Array.isArray(provider)) {
             forEachSingleProvider(provider, fn);
         }
+        else if (provider && isEnvironmentProviders(provider)) {
+            forEachSingleProvider(provider.ɵproviders, fn);
+        }
         else {
             fn(provider);
         }

package/import/es2015/error_details_base_url.js

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Base URL for the error details page.
+ *
+ * Keep this constant in sync across:
+ *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
+ *  - packages/core/src/error_details_base_url.ts
+ */
+export const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';
+/**
+ * URL for the XSS security documentation.
+ */
+export const XSS_SECURITY_URL = 'https://g.co/ng/security#xss';

package/import/es2015/errors.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Class that represents a runtime error.
+ * Formats and outputs the error message in a consistent way.
+ *
+ * Example:
+ * ```
+ *  throw new RuntimeError(
+ *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
+ *    ngDevMode && 'Injector has already been destroyed.');
+ * ```
+ *
+ * Note: the `message` argument contains a descriptive error message as a string in development
+ * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the
+ * `message` argument becomes `false`, thus we account for it in the typings and the runtime logic.
+ */
+export class RuntimeError extends Error {
+    constructor(code, message) {
+        super(formatRuntimeError(code, message));
+        this.code = code;
+    }
+}
+/**
+ * Called to format a runtime error.
+ * See additional info on the `message` argument type in the `RuntimeError` class description.
+ */
+export function formatRuntimeError(code, message) {
+    // Error code might be a negative number, which is a special marker that instructs the logic to
+    // generate a link to the error details page on angular.io.
+    // We also prepend `0` to non-compile-time errors.
+    const fullCode = `NG0${Math.abs(code)}`;
+    let errorMessage = `${fullCode}${message ? ': ' + message.trim() : ''}`;
+    if (false) {
+    }
+    return errorMessage;
+}

package/import/es2015/interface/type.js

@@ -5,4 +5,17 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-export {};
+/**
+ * @description
+ *
+ * Represents a type that a Component or other object is instances of.
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is represented by
+ * the `MyCustomComponent` constructor function.
+ *
+ * @publicApi
+ */
+export const Type = Function;
+export function isType(v) {
+    return typeof v === 'function';
+}

package/import/es2015/render3/definition_factory.js

@@ -8,8 +8,7 @@
 import { NG_FACTORY_DEF } from './fields';
 export function getFactoryDef(type, throwNotFound) {
     const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
-    // if (!hasFactoryDef && throwNotFound === true && ngDevMode) {
-    //   throw new Error(`Type ${stringify(type)} does not have 'ɵfac' property.`);
-    // }
+    if (false) {
+    }
     return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
 }

package/import/es2015/render3/errors_di.js

@@ -5,10 +5,9 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { RuntimeError } from './error_code';
-import { stringifyForError } from './util/stringify_utils';
+import { RuntimeError } from '../errors';
 /** Throws an error when a token is not found in DI. */
 export function throwProviderNotFoundError(token, injectorName) {
     const injectorDetails = injectorName ? ` in ${injectorName}` : '';
-    throw new RuntimeError("201" /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, `No provider for ${stringifyForError(token)} found${injectorDetails}`);
+    throw new RuntimeError(-201 /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, null);
 }

package/import/es2015/render3/instructions/di.js

@@ -1,10 +1,3 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
  * particular class.

package/import/es2015/render3/util/stringify_utils.js

@@ -12,10 +12,10 @@
  * Check `core/test/render3/perf/render_stringify` for benchmarks and alternate implementations.
  */
 export function renderStringify(value) {
-    if (typeof value === "string")
+    if (typeof value === 'string')
         return value;
     if (value == null)
-        return "";
+        return '';
     // Use `String` so that it invokes the `toString` method of the value. Note that this
     // appears to be faster than calling `value.toString` (see `render_stringify` benchmark).
     return String(value);
@@ -26,11 +26,11 @@ export function renderStringify(value) {
  * used for error messages.
  */
 export function stringifyForError(value) {
-    if (typeof value === "function")
+    if (typeof value === 'function')
         return value.name || value.toString();
-    if (typeof value === "object" &&
+    if (typeof value === 'object' &&
         value != null &&
-        typeof value.type === "function") {
+        typeof value.type === 'function') {
         return value.type.name || value.type.toString();
     }
     return renderStringify(value);

package/import/es2015/util/array_utils.js

@@ -1,10 +1,3 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 export function deepForEach(input, fn) {
     input.forEach((value) => Array.isArray(value) ? deepForEach(value, fn) : fn(value));
 }

package/import/es2015/util/decorators.js

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { noSideEffects } from './closure';
+export const PARAMETERS = '__parameters__';
 function makeMetadataCtor(props) {
     return function ctor(...args) {
         if (props) {
@@ -16,7 +17,7 @@ function makeMetadataCtor(props) {
         }
     };
 }
-export function makeParamDecorator(name, props) {
+export function makeParamDecorator(name, props, parentClass) {
     return noSideEffects(() => {
         const metaCtor = makeMetadataCtor(props);
         function ParamDecoratorFactory(...args) {
@@ -24,7 +25,29 @@ export function makeParamDecorator(name, props) {
                 metaCtor.apply(this, args);
                 return this;
             }
+            const annotationInstance = new ParamDecoratorFactory(...args);
+            ParamDecorator.annotation = annotationInstance;
+            return ParamDecorator;
+            function ParamDecorator(cls, unusedKey, index) {
+                // Use of Object.defineProperty is important since it creates non-enumerable property which
+                // prevents the property is copied during subclassing.
+                const parameters = cls.hasOwnProperty(PARAMETERS)
+                    ? cls[PARAMETERS]
+                    : Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];
+                // there might be gaps if some in between parameters do not have annotations.
+                // we pad with nulls.
+                while (parameters.length <= index) {
+                    parameters.push(null);
+                }
+                (parameters[index] = parameters[index] || []).push(annotationInstance);
+                return cls;
+            }
+        }
+        if (parentClass) {
+            ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
         }
+        ParamDecoratorFactory.prototype.ngMetadataName = name;
+        ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
         return ParamDecoratorFactory;
     });
 }

package/import/es2015/util/empty.js

@@ -11,4 +11,8 @@
  * allows for identity checks against these values to be consistently used by the framework
  * code.
  */
+export const EMPTY_OBJ = {};
 export const EMPTY_ARRAY = [];
+// freezing the values prevents any code from accidentally inserting new values in
+if (false) {
+}

package/import/es2015/util/stringify.js

@@ -6,14 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export function stringify(token) {
-    if (typeof token === "string") {
+    if (typeof token === 'string') {
         return token;
     }
     if (Array.isArray(token)) {
-        return "[" + token.map(stringify).join(", ") + "]";
+        return '[' + token.map(stringify).join(', ') + ']';
     }
     if (token == null) {
-        return "" + token;
+        return '' + token;
     }
     if (token.overriddenName) {
         return `${token.overriddenName}`;
@@ -23,8 +23,8 @@ export function stringify(token) {
     }
     const res = token.toString();
     if (res == null) {
-        return "" + res;
+        return '' + res;
     }
-    const newLineIndex = res.indexOf("\n");
+    const newLineIndex = res.indexOf('\n');
     return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
 }