static-injector 2.1.1 → 2.2.0

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

@@ -16,7 +16,7 @@ import { NullInjector } from './null_injector';
  * dependencies of various types with [injection tokens](guide/glossary#di-token).
  *
  * @see ["DI Providers"](guide/dependency-injection-providers).
- * @see `StaticProvider`
+ * @see {@link StaticProvider}
  *
  * @usageNotes
  *
@@ -35,27 +35,26 @@ import { NullInjector } from './null_injector';
  * @publicApi
  */
 export class Injector {
+    static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
+    static NULL = new NullInjector();
     static create(options, parent) {
-        var _a;
         if (Array.isArray(options)) {
             return createInjector({ name: '' }, parent, options, '');
         }
         else {
-            const name = (_a = options.name) !== null && _a !== void 0 ? _a : '';
+            const name = options.name ?? '';
             return createInjector({ name }, options.parent, options.providers, name);
         }
     }
+    /** @nocollapse */
+    static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({
+        token: Injector,
+        providedIn: 'any',
+        factory: () => ɵɵinject(INJECTOR),
+    });
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static __NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */;
 }
-Injector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
-Injector.NULL = new NullInjector();
-/** @nocollapse */
-Injector.ɵprov = ɵɵdefineInjectable({
-    token: Injector,
-    providedIn: 'any',
-    factory: () => ɵɵinject(INJECTOR),
-});
-/**
- * @internal
- * @nocollapse
- */
-Injector.__NG_ELEMENT_ID__ = -1 /* InjectorMarkers.Injector */;

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

@@ -30,6 +30,9 @@ export const SOURCE = '__source';
  * - Injector instance: Use the injector for resolution.
  */
 let _currentInjector = undefined;
+export function getCurrentInjector() {
+    return _currentInjector;
+}
 export function setCurrentInjector(injector) {
     const former = _currentInjector;
     _currentInjector = injector;
@@ -43,7 +46,8 @@ export function injectInjectorOnly(token, flags = InjectFlags.Default) {
         return injectRootLimpMode(token, undefined, flags);
     }
     else {
-        return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);
+        const value = _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);
+        return value;
     }
 }
 export function ɵɵinject(token, flags = InjectFlags.Default) {
@@ -63,13 +67,14 @@ export function ɵɵinvalidFactoryDep(index) {
 }
 /**
  * Injects a token from the currently active injector.
- * `inject` is only supported during instantiation of a dependency by the DI system. It can be used
- * during:
+ * `inject` is only supported in an [injection context](/guide/dependency-injection-context). It can
+ * be used during:
  * - Construction (via the `constructor`) of a class being instantiated by the DI system, such
  * as an `@Injectable` or `@Component`.
  * - In the initializer for fields of such classes.
  * - In the factory function specified for `useFactory` of a `Provider` or an `@Injectable`.
  * - In the `factory` function specified for an `InjectionToken`.
+ * - In a stackframe of a function call in a DI context
  *
  * @param token A token that represents a dependency that should be injected.
  * @param flags Optional flags that control how injection is executed.

package/import/{es2015 → es2022}/di/interface/defs.js

@@ -18,7 +18,8 @@ import { getClosureSafeProperty } from '../../util/property';
  *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be
  *   provided in the `'root'` injector, which will be the application-level injector in most apps.
  * * `factory` gives the zero argument function which will create an instance of the injectable.
- *   The factory can call `inject` to access the `Injector` and request injection of dependencies.
+ *   The factory can call [`inject`](api/core/inject) to access the `Injector` and request injection
+ * of dependencies.
  *
  * @codeGenApi
  * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.
@@ -81,27 +82,12 @@ function getOwnDefinition(type, field) {
 export function getInheritedInjectableDef(type) {
     const def = type && (type[NG_PROV_DEF] || null);
     if (def) {
-        const typeName = getTypeName(type);
         return def;
     }
     else {
         return null;
     }
 }
-/** Gets the name of a type, accounting for some cross-browser differences. */
-function getTypeName(type) {
-    // `Function.prototype.name` behaves differently between IE and other browsers. In most browsers
-    // it'll always return the name of the function itself, no matter how many other functions it
-    // inherits from. On IE the function doesn't have its own `name` property, but it takes it from
-    // the lowest level in the prototype chain. E.g. if we have `class Foo extends Parent` most
-    // browsers will evaluate `Foo.name` to `Foo` while IE will return `Parent`. We work around
-    // the issue by converting the function to a string and parsing its name out that way via a regex.
-    if (type.hasOwnProperty('name')) {
-        return type.name;
-    }
-    const match = ('' + type).match(/^function\s*([^\s(]+)/);
-    return match === null ? '' : match[1];
-}
 /**
  * Read the injector def type in a way which is immune to accidentally reading inherited value.
  *

package/import/{es2015 → es2022}/di/interface/injector.js

@@ -9,7 +9,7 @@
  * Injection flags for DI.
  *
  * @publicApi
- * @deprecated use an options object for `inject` instead.
+ * @deprecated use an options object for [`inject`](api/core/inject) instead.
  */
 export var InjectFlags;
 (function (InjectFlags) {

package/import/es2022/di/provider_collection.js

@@ -0,0 +1,104 @@
+/**
+ * @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';
+/**
+ * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
+ * referenced in `@Component` in a component injector.
+ */
+export function makeEnvironmentProviders(providers) {
+    return {
+        ɵproviders: providers,
+    };
+}
+/**
+ * Collects providers from all NgModules and standalone components, including transitively imported
+ * ones.
+ *
+ * Providers extracted via `importProvidersFrom` are only usable in an application injector or
+ * another environment injector (such as a route injector). They should not be used in component
+ * providers.
+ *
+ * More information about standalone components can be found in [this
+ * guide](guide/standalone-components).
+ *
+ * @usageNotes
+ * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:
+ *
+ * ```typescript
+ * await bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *   ]
+ * });
+ * ```
+ *
+ * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a
+ * standalone component is used:
+ *
+ * ```typescript
+ * export const ROUTES: Route[] = [
+ *   {
+ *     path: 'foo',
+ *     providers: [
+ *       importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *     ],
+ *     component: YourStandaloneComponent
+ *   }
+ * ];
+ * ```
+ *
+ * @returns Collected providers from the specified list of types.
+ * @publicApi
+ */
+export function importProvidersFrom(...sources) {
+    return {
+        ɵproviders: internalImportProvidersFrom(true, sources),
+        ɵfromNgModule: true,
+    };
+}
+export function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
+    const providersOut = [];
+    const dedup = new Set(); // already seen types
+    let injectorTypesWithProviders;
+    const collectProviders = (provider) => {
+        providersOut.push(provider);
+    };
+    // Collect all providers from `ModuleWithProviders` types.
+    if (injectorTypesWithProviders !== undefined) {
+        processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
+    }
+    return providersOut;
+}
+/**
+ * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided
+ * array.
+ */
+function processInjectorTypesWithProviders(typesWithProviders, visitor) {
+    for (let i = 0; i < typesWithProviders.length; i++) {
+        const { ngModule, providers } = typesWithProviders[i];
+    }
+}
+export const USE_VALUE = getClosureSafeProperty({
+    provide: String,
+    useValue: getClosureSafeProperty,
+});
+export function isValueProvider(value) {
+    return value !== null && typeof value == 'object' && USE_VALUE in value;
+}
+export function isExistingProvider(value) {
+    return !!(value && value.useExisting);
+}
+export function isFactoryProvider(value) {
+    return !!(value && value.useFactory);
+}
+export function isTypeProvider(value) {
+    return typeof value === 'function';
+}
+export function isClassProvider(value) {
+    return !!value.useClass;
+}

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

@@ -7,6 +7,7 @@
  */
 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';
@@ -52,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.
@@ -106,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();
             }
         }
@@ -115,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();
         }
@@ -135,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 {
@@ -204,6 +221,8 @@ 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) {
@@ -242,6 +261,8 @@ 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.
@@ -271,7 +292,11 @@ export class R3Injector extends EnvironmentInjector {
         }
         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 &&
@@ -292,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.

package/import/{es2015 → es2022}/errors.js

@@ -18,9 +18,11 @@
  *
  * 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.
+ * `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;
@@ -35,7 +37,7 @@ export function formatRuntimeError(code, message) {
     // 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() : ''}`;
+    let errorMessage = `${fullCode}${message ? ': ' + message : ''}`;
     if (false) {
     }
     return errorMessage;

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/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,
+});