static-injector 2.1.0 → 2.2.0

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

@@ -7,11 +7,10 @@
  */
 import { EMPTY_ARRAY } from '../util/empty';
 import { stringify } from '../util/stringify';
+import { importProvidersFrom } from './provider_collection';
 import { getNullInjector, R3Injector } from './r3_injector';
 /**
  * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
  */
 export function createInjector(defType, parent = null, additionalProviders = null, name) {
     const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
@@ -24,7 +23,10 @@ export function createInjector(defType, parent = null, additionalProviders = nul
  * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
  */
 export function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = new Set()) {
-    const providers = [additionalProviders || EMPTY_ARRAY];
+    const providers = [
+        additionalProviders || EMPTY_ARRAY,
+        importProvidersFrom(defType),
+    ];
     name = name || (typeof defType === 'object' ? undefined : stringify(defType));
     return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
 }

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

@@ -5,8 +5,8 @@
  * 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";
-import { stringify } from "../util/stringify";
+import { getClosureSafeProperty } from '../util/property';
+import { stringify } from '../util/stringify';
 const __forward_ref__ = getClosureSafeProperty({
     __forward_ref__: getClosureSafeProperty,
 });
@@ -17,9 +17,36 @@ const __forward_ref__ = getClosureSafeProperty({
  * DI is declared, but not yet defined. It is also used when the `token` which we use when creating
  * a query is not yet defined.
  *
+ * `forwardRef` is also used to break circularities in standalone components imports.
+ *
  * @usageNotes
- * ### Example
+ * ### Circular dependency example
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
+ *
+ * ### Circular standalone reference import example
+ * ```ts
+ * @Component({
+ *   standalone: true,
+ *   imports: [ChildComponent],
+ *   selector: 'app-parent',
+ *   template: `<app-child [hideParent]="hideParent"></app-child>`,
+ * })
+ * export class ParentComponent {
+ *   @Input() hideParent: boolean;
+ * }
+ *
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [CommonModule, forwardRef(() => ParentComponent)],
+ *   selector: 'app-child',
+ *   template: `<app-parent *ngIf="!hideParent"></app-parent>`,
+ * })
+ * export class ChildComponent {
+ *   @Input() hideParent: boolean;
+ * }
+ * ```
+ *
  * @publicApi
  */
 export function forwardRef(forwardRefFn) {
@@ -39,7 +66,7 @@ export function forwardRef(forwardRefFn) {
  *
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
  *
- * @see `forwardRef`
+ * @see {@link forwardRef}
  * @publicApi
  */
 export function resolveForwardRef(type) {
@@ -47,7 +74,7 @@ export function resolveForwardRef(type) {
 }
 /** Checks whether a function is wrapped by a `forwardRef`. */
 export function isForwardRef(fn) {
-    return (typeof fn === "function" &&
+    return (typeof fn === 'function' &&
         fn.hasOwnProperty(__forward_ref__) &&
         fn.__forward_ref__ === forwardRef);
 }

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

@@ -14,11 +14,11 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * parameterized type.
  *
  * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
- * the `Injector`. This provides additional level of type safety.
+ * the `Injector`. This provides an additional level of type safety.
  *
  * ```
  * interface MyInterface {...}
- * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
+ * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
  * // myInterface is inferred to be MyInterface.
  * ```
  *
@@ -26,14 +26,18 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * (possibly by creating) a default value of the parameterized type `T`. This sets up the
  * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
  * application's root injector. If the factory function, which takes zero arguments, needs to inject
- * dependencies, it can do so using the `inject` function. See below for an example.
+ * dependencies, it can do so using the [`inject`](api/core/inject) function.
+ * As you can see in the Tree-shakable InjectionToken example below.
  *
  * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
- * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As
- * mentioned above, `'root'` is the default value for `providedIn`.
+ * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
+ * this option is now deprecated). As mentioned above, `'root'` is the default value for
+ * `providedIn`.
+ *
+ * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
  *
  * @usageNotes
- * ### Basic Example
+ * ### Basic Examples
  *
  * ### Plain InjectionToken
  *
@@ -47,15 +51,20 @@ import { ɵɵdefineInjectable } from './interface/defs';
  * @publicApi
  */
 export class InjectionToken {
+    _desc;
+    /** @internal */
+    ngMetadataName = 'InjectionToken';
+    ɵprov;
+    /**
+     * @param _desc   Description for the token,
+     *                used only for debugging purposes,
+     *                it should but does not need to be unique
+     * @param options Options for the token's usage, as described above
+     */
     constructor(_desc, options) {
         this._desc = _desc;
         this.ɵprov = undefined;
         if (typeof options == 'number') {
-            // (typeof ngDevMode === "undefined" || ngDevMode) &&
-            //   assertLessThan(options, 0, "Only negative numbers are supported here");
-            // // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.
-            // // See `InjectorMarkers`
-            // (this as any).__NG_ELEMENT_ID__ = options;
         }
         else if (options !== undefined) {
             this.ɵprov = ɵɵdefineInjectable({

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

@@ -5,10 +5,10 @@
  * 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';
+import { RuntimeError } from '../errors';
 import { stringify } from '../util/stringify';
 import { resolveForwardRef } from './forward_ref';
-import { injectRootLimpMode } from './inject_switch';
+import { getInjectImplementation, injectRootLimpMode } from './inject_switch';
 import { InjectFlags, } from './interface/injector';
 const _THROW_IF_NOT_FOUND = {};
 export const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
@@ -23,10 +23,6 @@ const NG_TOKEN_PATH = 'ngTokenPath';
 const NEW_LINE = /\n/gm;
 const NO_NEW_LINE = 'ɵ';
 export const SOURCE = '__source';
-export const USE_VALUE = getClosureSafeProperty({
-    provide: String,
-    useValue: getClosureSafeProperty,
-});
 /**
  * Current injector value used by `inject`.
  * - `undefined`: it is an error to call `inject`
@@ -34,6 +30,9 @@ export const USE_VALUE = getClosureSafeProperty({
  * - Injector instance: Use the injector for resolution.
  */
 let _currentInjector = undefined;
+export function getCurrentInjector() {
+    return _currentInjector;
+}
 export function setCurrentInjector(injector) {
     const former = _currentInjector;
     _currentInjector = injector;
@@ -41,32 +40,46 @@ export function setCurrentInjector(injector) {
 }
 export function injectInjectorOnly(token, flags = InjectFlags.Default) {
     if (_currentInjector === undefined) {
-        throw new Error(`inject() must be called from an injection context`);
+        throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, null);
     }
     else if (_currentInjector === null) {
         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) {
-    return injectInjectorOnly(resolveForwardRef(token), flags);
+    return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
+}
+/**
+ * Throws an error indicating that a factory function could not be generated by the compiler for a
+ * particular class.
+ *
+ * The name of the class is not mentioned here, but will be in the generated factory function name
+ * and thus in the stack trace.
+ *
+ * @codeGenApi
+ */
+export function ɵɵinvalidFactoryDep(index) {
+    throw new RuntimeError(202 /* RuntimeErrorCode.INVALID_FACTORY_DEPENDENCY */, null);
 }
 /**
  * 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.
  * The flags correspond to injection strategies that can be specified with
- * parameter decorators `@Host`, `@Self`, `@SkipSef`, and `@Optional`.
+ * parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.
  * @returns the injected value if operation is successful, `null` otherwise.
  * @throws if called outside of a supported context.
  *
@@ -130,6 +143,7 @@ export function convertToBitFlags(flags) {
     // `InjectOptions` to `InjectFlags`.
     return (0 /* InternalInjectFlags.Default */ | // comment to force a line break in the formatter
         (flags.optional && 8 /* InternalInjectFlags.Optional */) |
+        0 |
         (flags.self && 2 /* InternalInjectFlags.Self */) |
         (flags.skipSelf &&
             4 /* InternalInjectFlags.SkipSelf */));
@@ -140,7 +154,7 @@ export function injectArgs(types) {
         const arg = resolveForwardRef(types[i]);
         if (Array.isArray(arg)) {
             if (arg.length === 0) {
-                throw new Error('Arguments array must have arguments.');
+                throw new RuntimeError(900 /* RuntimeErrorCode.INVALID_DIFFER_INPUT */, null);
             }
             let type = undefined;
             let flags = InjectFlags.Default;

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

@@ -5,7 +5,7 @@
  * 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 { InjectionToken } from "./injection_token";
+import { InjectionToken } from './injection_token';
 /**
  * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.
  *
@@ -14,8 +14,8 @@ import { InjectionToken } from "./injection_token";
  *
  * @publicApi
  */
-export const INJECTOR = new InjectionToken("INJECTOR", 
-// Dissable tslint because this is const enum which gets inlined not top level prop access.
+export const INJECTOR = new InjectionToken('INJECTOR', 
+// Disable tslint because this is const enum which gets inlined not top level prop access.
 // tslint:disable-next-line: no-toplevel-property-access
 -1 /* InjectorMarkers.Injector */ // Special value used by Ivy to identify `Injector`.
 );

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.
@@ -58,7 +59,10 @@ export function ɵɵdefineInjector(options) {
  * @param type A type which may have its own (non-inherited) `ɵprov`.
  */
 export function getInjectableDef(type) {
-    return getOwnDefinition(type, NG_PROV_DEF);
+    return getOwnDefinition(type, NG_PROV_DEF) || null;
+}
+export function isInjectable(type) {
+    return getInjectableDef(type) !== null;
 }
 /**
  * Return definition only if it is defined directly on `type` and is not inherited from a base
@@ -67,9 +71,6 @@ export function getInjectableDef(type) {
 function getOwnDefinition(type, field) {
     return type.hasOwnProperty(field) ? type[field] : null;
 }
-export const NG_PROV_DEF = getClosureSafeProperty({
-    ɵprov: getClosureSafeProperty,
-});
 /**
  * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
  *
@@ -79,33 +80,27 @@ export const NG_PROV_DEF = getClosureSafeProperty({
  *     scenario if we find the `ɵprov` on an ancestor only.
  */
 export function getInheritedInjectableDef(type) {
-    const def = type && (type[NG_PROV_DEF] || type[NG_INJECTABLE_DEF]);
+    const def = type && (type[NG_PROV_DEF] || null);
     if (def) {
-        const typeName = getTypeName(type);
-        // TODO(FW-1307): Re-add ngDevMode when closure can handle it
-        // ngDevMode &&
-        console.warn(`DEPRECATED: DI is instantiating a token "${typeName}" that inherits its @Injectable decorator but does not provide one itself.\n` +
-            `This will become an error in a future version of Angular. Please add @Injectable() to the "${typeName}" class.`);
         return def;
     }
     else {
         return null;
     }
 }
-export const NG_INJECTABLE_DEF = getClosureSafeProperty({
-    ngInjectableDef: getClosureSafeProperty,
-});
-/** 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.
+ *
+ * @param type type which may have an injector def (`ɵinj`)
+ */
+export function getInjectorDef(type) {
+    return type && (type.hasOwnProperty(NG_INJ_DEF) || false)
+        ? type[NG_INJ_DEF]
+        : null;
 }
+export const NG_PROV_DEF = getClosureSafeProperty({
+    ɵprov: getClosureSafeProperty,
+});
+export const NG_INJ_DEF = getClosureSafeProperty({
+    ɵinj: getClosureSafeProperty,
+});

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/{es2015 → es2022}/di/interface/provider.js

@@ -5,4 +5,6 @@
  * 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 {};
+export function isEnvironmentProviders(value) {
+    return value && !!value.ɵproviders;
+}

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

@@ -5,13 +5,13 @@
  * 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 { stringify } from "../util/stringify";
-import { THROW_IF_NOT_FOUND } from "./injector_compatibility";
+import { stringify } from '../util/stringify';
+import { THROW_IF_NOT_FOUND } from './injector_compatibility';
 export class NullInjector {
     get(token, notFoundValue = THROW_IF_NOT_FOUND) {
         if (notFoundValue === THROW_IF_NOT_FOUND) {
             const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
-            error.name = "NullInjectorError";
+            error.name = 'NullInjectorError';
             throw error;
         }
         return notFoundValue;

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;
+}