static-injector 2.1.0 → 2.2.0

package/import/{es2015 → es2022}/di/r3_injector.js

@@ -5,20 +5,24 @@
  * 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 { NG_ENV_ID } from '../render3/fields';
 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,29 +53,33 @@ export function getNullInjector() {
 export class EnvironmentInjector {
 }
 export class R3Injector extends EnvironmentInjector {
+    parent;
+    source;
+    scopes;
+    /**
+     * Map of tokens to records which contain the instances of those tokens.
+     * - `null` value implies that we don't have the record. Used by tree-shakable injectors
+     * to prevent further searches.
+     */
+    records = new Map();
+    /**
+     * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
+     */
+    _ngOnDestroyHooks = new Set();
+    _onDestroyHooks = [];
     /**
      * Flag indicating that this injector was previously destroyed.
      */
     get destroyed() {
         return this._destroyed;
     }
+    _destroyed = false;
+    injectorDefTypes;
     constructor(providers, parent, source, scopes) {
         super();
         this.parent = parent;
         this.source = source;
         this.scopes = scopes;
-        /**
-         * Map of tokens to records which contain the instances of those tokens.
-         * - `null` value implies that we don't have the record. Used by tree-shakable injectors
-         * to prevent further searches.
-         */
-        this.records = new Map();
-        /**
-         * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
-         */
-        this._ngOnDestroyHooks = new Set();
-        this._onDestroyHooks = [];
-        this._destroyed = false;
         // Start off by creating Records for every provider.
         forEachSingleProvider(providers, (provider) => this.processProvider(provider));
         // Make sure the INJECTOR token provides this injector.
@@ -103,7 +111,11 @@ export class R3Injector extends EnvironmentInjector {
             for (const service of this._ngOnDestroyHooks) {
                 service.ngOnDestroy();
             }
-            for (const hook of this._onDestroyHooks) {
+            const onDestroyHooks = this._onDestroyHooks;
+            // Reset the _onDestroyHooks array before iterating over it to prevent hooks that unregister
+            // themselves from mutating the array during iteration.
+            this._onDestroyHooks = [];
+            for (const hook of onDestroyHooks) {
                 hook();
             }
         }
@@ -112,16 +124,19 @@ export class R3Injector extends EnvironmentInjector {
             this.records.clear();
             this._ngOnDestroyHooks.clear();
             this.injectorDefTypes.clear();
-            this._onDestroyHooks.length = 0;
         }
     }
     onDestroy(callback) {
+        this.assertNotDestroyed();
         this._onDestroyHooks.push(callback);
+        return () => this.removeOnDestroy(callback);
     }
     runInContext(fn) {
         this.assertNotDestroyed();
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
+        if (false) {
+        }
         try {
             return fn();
         }
@@ -132,8 +147,13 @@ export class R3Injector extends EnvironmentInjector {
     }
     get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
         this.assertNotDestroyed();
+        if (token.hasOwnProperty(NG_ENV_ID)) {
+            return token[NG_ENV_ID](this);
+        }
         flags = convertToBitFlags(flags);
         // Set the injection context.
+        if (false) {
+        }
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
         try {
@@ -201,8 +221,12 @@ export class R3Injector extends EnvironmentInjector {
     resolveInjectorInitializers() {
         const previousInjector = setCurrentInjector(this);
         const previousInjectImplementation = setInjectImplementation(undefined);
+        if (false) {
+        }
         try {
             const initializers = this.get(ENVIRONMENT_INITIALIZER.multi, EMPTY_ARRAY, InjectFlags.Self);
+            if (false) {
+            }
             for (const initializer of initializers) {
                 initializer();
             }
@@ -222,7 +246,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);
         }
     }
     /**
@@ -237,12 +261,16 @@ export class R3Injector extends EnvironmentInjector {
             : resolveForwardRef(provider && provider.provide);
         // Construct a `Record` for the provider.
         const record = providerToRecord(provider);
+        if (false) {
+        }
         if (!isTypeProvider(provider) && provider.multi === true) {
             // If the provider indicates that it's a multi-provider, process it specially.
             // First check whether it's been defined already.
             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,13 +282,21 @@ 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();
+            if (false) {
+            }
+            else {
+                record.value = record.factory();
+            }
         }
         if (typeof record.value === 'object' &&
             record.value &&
@@ -281,6 +317,12 @@ export class R3Injector extends EnvironmentInjector {
             return this.injectorDefTypes.has(providedIn);
         }
     }
+    removeOnDestroy(callback) {
+        const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
+        if (destroyCBIdx !== -1) {
+            this._onDestroyHooks.splice(destroyCBIdx, 1);
+        }
+    }
 }
 function injectableDefOrInjectorDefFactory(token) {
     // Most tokens will have an injectable def directly on them, which specifies a factory directly.
@@ -292,21 +334,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 +379,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 +400,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 +419,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 +436,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/es2022/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/es2022/errors.js

@@ -0,0 +1,44 @@
+/**
+ * @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 {
+    code;
+    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 : ''}`;
+    if (false) {
+    }
+    return errorMessage;
+}

package/import/es2022/interface/type.js

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+/**
+ * @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 → es2022}/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 → es2022}/render3/error_code.js

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export class RuntimeError extends Error {
+    code;
     constructor(code, message) {
         super(formatRuntimeError(code, message));
         this.code = code;

package/import/{es2015 → es2022}/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/es2022/render3/fields.js

@@ -0,0 +1,22 @@
+/**
+ * @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
+ */
+import { getClosureSafeProperty } from '../util/property';
+export const NG_FACTORY_DEF = getClosureSafeProperty({
+    ɵfac: getClosureSafeProperty,
+});
+/**
+ * The `NG_ENV_ID` field on a DI token indicates special processing in the `EnvironmentInjector`:
+ * getting such tokens from the `EnvironmentInjector` will bypass the standard DI resolution
+ * strategy and instead will return implementation produced by the `NG_ENV_ID` factory function.
+ *
+ * This particular retrieval of DI tokens is mostly done to eliminate circular dependencies and
+ * improve tree-shaking.
+ */
+export const NG_ENV_ID = getClosureSafeProperty({
+    __NG_ENV_ID__: getClosureSafeProperty,
+});

package/import/{es2015 → es2022}/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 → es2022}/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 → es2022}/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/es2022/util/decorators.js

@@ -0,0 +1,53 @@
+/**
+ * @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
+ */
+import { noSideEffects } from './closure';
+export const PARAMETERS = '__parameters__';
+function makeMetadataCtor(props) {
+    return function ctor(...args) {
+        if (props) {
+            const values = props(...args);
+            for (const propName in values) {
+                this[propName] = values[propName];
+            }
+        }
+    };
+}
+export function makeParamDecorator(name, props, parentClass) {
+    return noSideEffects(() => {
+        const metaCtor = makeMetadataCtor(props);
+        function ParamDecoratorFactory(...args) {
+            if (this instanceof ParamDecoratorFactory) {
+                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 → es2022}/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 → es2022}/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);
 }