@angular/core 16.0.0-next.4 → 16.0.0-next.6

package/esm2022/src/di/injector_compatibility.mjs

@@ -0,0 +1,239 @@
+/**
+ * @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 '../util/ng_dev_mode';
+import { RuntimeError } from '../errors';
+import { stringify } from '../util/stringify';
+import { resolveForwardRef } from './forward_ref';
+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;
+/*
+ * Name of a property (that we patch onto DI decorator), which is used as an annotation of which
+ * InjectFlag this decorator represents. This allows to avoid direct references to the DI decorators
+ * in the code, thus making them tree-shakable.
+ */
+const DI_DECORATOR_FLAG = '__NG_DI_FLAG__';
+export const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';
+const NG_TOKEN_PATH = 'ngTokenPath';
+const NEW_LINE = /\n/gm;
+const NO_NEW_LINE = 'ɵ';
+export const SOURCE = '__source';
+/**
+ * Current injector value used by `inject`.
+ * - `undefined`: it is an error to call `inject`
+ * - `null`: `inject` can be called but there is no injector (limp-mode).
+ * - Injector instance: Use the injector for resolution.
+ */
+let _currentInjector = undefined;
+export function getCurrentInjector() {
+    return _currentInjector;
+}
+export function setCurrentInjector(injector) {
+    const former = _currentInjector;
+    _currentInjector = injector;
+    return former;
+}
+export function injectInjectorOnly(token, flags = InjectFlags.Default) {
+    if (_currentInjector === undefined) {
+        throw new RuntimeError(-203 /* RuntimeErrorCode.MISSING_INJECTION_CONTEXT */, ngDevMode &&
+            `inject() must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\`.`);
+    }
+    else if (_currentInjector === null) {
+        return injectRootLimpMode(token, undefined, flags);
+    }
+    else {
+        return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);
+    }
+}
+export function ɵɵinject(token, flags = InjectFlags.Default) {
+    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 */, ngDevMode &&
+        `This constructor is not compatible with Angular Dependency Injection because its dependency at index ${index} of the parameter list is invalid.
+This can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.
+
+Please check that 1) the type for the parameter at index ${index} is correct and 2) the correct Angular decorators are defined for this class and its ancestors.`);
+}
+/**
+ * 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:
+ * - 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`.
+ *
+ * @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`, `@SkipSelf`, and `@Optional`.
+ * @returns the injected value if operation is successful, `null` otherwise.
+ * @throws if called outside of a supported context.
+ *
+ * @usageNotes
+ * In practice the `inject()` calls are allowed in a constructor, a constructor parameter and a
+ * field initializer:
+ *
+ * ```typescript
+ * @Injectable({providedIn: 'root'})
+ * export class Car {
+ *   radio: Radio|undefined;
+ *   // OK: field initializer
+ *   spareTyre = inject(Tyre);
+ *
+ *   constructor() {
+ *     // OK: constructor body
+ *     this.radio = inject(Radio);
+ *   }
+ * }
+ * ```
+ *
+ * It is also legal to call `inject` from a provider's factory:
+ *
+ * ```typescript
+ * providers: [
+ *   {provide: Car, useFactory: () => {
+ *     // OK: a class factory
+ *     const engine = inject(Engine);
+ *     return new Car(engine);
+ *   }}
+ * ]
+ * ```
+ *
+ * Calls to the `inject()` function outside of the class creation context will result in error. Most
+ * notably, calls to `inject()` are disallowed after a class instance was created, in methods
+ * (including lifecycle hooks):
+ *
+ * ```typescript
+ * @Component({ ... })
+ * export class CarComponent {
+ *   ngOnInit() {
+ *     // ERROR: too late, the component instance was already created
+ *     const engine = inject(Engine);
+ *     engine.start();
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+export function inject(token, flags = InjectFlags.Default) {
+    return ɵɵinject(token, convertToBitFlags(flags));
+}
+// Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).
+export function convertToBitFlags(flags) {
+    if (typeof flags === 'undefined' || typeof flags === 'number') {
+        return flags;
+    }
+    // While TypeScript doesn't accept it without a cast, bitwise OR with false-y values in
+    // JavaScript is a no-op. We can use that for a very codesize-efficient conversion from
+    // `InjectOptions` to `InjectFlags`.
+    return (0 /* InternalInjectFlags.Default */ | // comment to force a line break in the formatter
+        (flags.optional && 8 /* InternalInjectFlags.Optional */) |
+        (flags.host && 1 /* InternalInjectFlags.Host */) |
+        (flags.self && 2 /* InternalInjectFlags.Self */) |
+        (flags.skipSelf && 4 /* InternalInjectFlags.SkipSelf */));
+}
+export function injectArgs(types) {
+    const args = [];
+    for (let i = 0; i < types.length; i++) {
+        const arg = resolveForwardRef(types[i]);
+        if (Array.isArray(arg)) {
+            if (arg.length === 0) {
+                throw new RuntimeError(900 /* RuntimeErrorCode.INVALID_DIFFER_INPUT */, ngDevMode && 'Arguments array must have arguments.');
+            }
+            let type = undefined;
+            let flags = InjectFlags.Default;
+            for (let j = 0; j < arg.length; j++) {
+                const meta = arg[j];
+                const flag = getInjectFlag(meta);
+                if (typeof flag === 'number') {
+                    // Special case when we handle @Inject decorator.
+                    if (flag === -1 /* DecoratorFlags.Inject */) {
+                        type = meta.token;
+                    }
+                    else {
+                        flags |= flag;
+                    }
+                }
+                else {
+                    type = meta;
+                }
+            }
+            args.push(ɵɵinject(type, flags));
+        }
+        else {
+            args.push(ɵɵinject(arg));
+        }
+    }
+    return args;
+}
+/**
+ * Attaches a given InjectFlag to a given decorator using monkey-patching.
+ * Since DI decorators can be used in providers `deps` array (when provider is configured using
+ * `useFactory`) without initialization (e.g. `Host`) and as an instance (e.g. `new Host()`), we
+ * attach the flag to make it available both as a static property and as a field on decorator
+ * instance.
+ *
+ * @param decorator Provided DI decorator.
+ * @param flag InjectFlag that should be applied.
+ */
+export function attachInjectFlag(decorator, flag) {
+    decorator[DI_DECORATOR_FLAG] = flag;
+    decorator.prototype[DI_DECORATOR_FLAG] = flag;
+    return decorator;
+}
+/**
+ * Reads monkey-patched property that contains InjectFlag attached to a decorator.
+ *
+ * @param token Token that may contain monkey-patched DI flags property.
+ */
+export function getInjectFlag(token) {
+    return token[DI_DECORATOR_FLAG];
+}
+export function catchInjectorError(e, token, injectorErrorName, source) {
+    const tokenPath = e[NG_TEMP_TOKEN_PATH];
+    if (token[SOURCE]) {
+        tokenPath.unshift(token[SOURCE]);
+    }
+    e.message = formatError('\n' + e.message, tokenPath, injectorErrorName, source);
+    e[NG_TOKEN_PATH] = tokenPath;
+    e[NG_TEMP_TOKEN_PATH] = null;
+    throw e;
+}
+export function formatError(text, obj, injectorErrorName, source = null) {
+    text = text && text.charAt(0) === '\n' && text.charAt(1) == NO_NEW_LINE ? text.slice(2) : text;
+    let context = stringify(obj);
+    if (Array.isArray(obj)) {
+        context = obj.map(stringify).join(' -> ');
+    }
+    else if (typeof obj === 'object') {
+        let parts = [];
+        for (let key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                let value = obj[key];
+                parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));
+            }
+        }
+        context = `{${parts.join(', ')}}`;
+    }
+    return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(NEW_LINE, '\n  ')}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector_compatibility.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/di/injector_compatibility.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport '../util/ng_dev_mode';\n\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {Type} from '../interface/type';\nimport {stringify} from '../util/stringify';\n\nimport {resolveForwardRef} from './forward_ref';\nimport {getInjectImplementation, injectRootLimpMode} from './inject_switch';\nimport {Injector} from './injector';\nimport {DecoratorFlags, InjectFlags, InjectOptions, InternalInjectFlags} from './interface/injector';\nimport {ProviderToken} from './provider_token';\n\n\nconst _THROW_IF_NOT_FOUND = {};\nexport const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n\n/*\n * Name of a property (that we patch onto DI decorator), which is used as an annotation of which\n * InjectFlag this decorator represents. This allows to avoid direct references to the DI decorators\n * in the code, thus making them tree-shakable.\n */\nconst DI_DECORATOR_FLAG = '__NG_DI_FLAG__';\n\nexport const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\nconst NG_TOKEN_PATH = 'ngTokenPath';\nconst NEW_LINE = /\\n/gm;\nconst NO_NEW_LINE = 'ɵ';\nexport const SOURCE = '__source';\n\n/**\n * Current injector value used by `inject`.\n * - `undefined`: it is an error to call `inject`\n * - `null`: `inject` can be called but there is no injector (limp-mode).\n * - Injector instance: Use the injector for resolution.\n */\nlet _currentInjector: Injector|undefined|null = undefined;\n\nexport function getCurrentInjector(): Injector|undefined|null {\n  return _currentInjector;\n}\n\nexport function setCurrentInjector(injector: Injector|null|undefined): Injector|undefined|null {\n  const former = _currentInjector;\n  _currentInjector = injector;\n  return former;\n}\n\nexport function injectInjectorOnly<T>(token: ProviderToken<T>): T;\nexport function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: InjectFlags): T|null;\nexport function injectInjectorOnly<T>(token: ProviderToken<T>, flags = InjectFlags.Default): T|\n    null {\n  if (_currentInjector === undefined) {\n    throw new RuntimeError(\n        RuntimeErrorCode.MISSING_INJECTION_CONTEXT,\n        ngDevMode &&\n            `inject() must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \\`runInInjectionContext\\`.`);\n  } else if (_currentInjector === null) {\n    return injectRootLimpMode(token, undefined, flags);\n  } else {\n    return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);\n  }\n}\n\n/**\n * Generated instruction: injects a token from the currently active injector.\n *\n * (Additional documentation moved to `inject`, as it is the public API, and an alias for this\n * instruction)\n *\n * @see inject\n * @codeGenApi\n * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.\n */\nexport function ɵɵinject<T>(token: ProviderToken<T>): T;\nexport function ɵɵinject<T>(token: ProviderToken<T>, flags?: InjectFlags): T|null;\nexport function ɵɵinject<T>(token: ProviderToken<T>, flags = InjectFlags.Default): T|null {\n  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);\n}\n\n/**\n * Throws an error indicating that a factory function could not be generated by the compiler for a\n * particular class.\n *\n * The name of the class is not mentioned here, but will be in the generated factory function name\n * and thus in the stack trace.\n *\n * @codeGenApi\n */\nexport function ɵɵinvalidFactoryDep(index: number): never {\n  throw new RuntimeError(\n      RuntimeErrorCode.INVALID_FACTORY_DEPENDENCY,\n      ngDevMode &&\n          `This constructor is not compatible with Angular Dependency Injection because its dependency at index ${\n              index} of the parameter list is invalid.\nThis can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.\n\nPlease check that 1) the type for the parameter at index ${\n              index} is correct and 2) the correct Angular decorators are defined for this class and its ancestors.`);\n}\n\n/**\n * @param token A token that represents a dependency that should be injected.\n * @returns the injected value if operation is successful, `null` otherwise.\n * @throws if called outside of a supported context.\n *\n * @publicApi\n */\nexport function inject<T>(token: ProviderToken<T>): T;\n/**\n * @param token A token that represents a dependency that should be injected.\n * @param flags Control how injection is executed. The flags correspond to injection strategies that\n *     can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.\n * @returns the injected value if operation is successful, `null` otherwise.\n * @throws if called outside of a supported context.\n *\n * @publicApi\n * @deprecated prefer an options object instead of `InjectFlags`\n */\nexport function inject<T>(token: ProviderToken<T>, flags?: InjectFlags): T|null;\n/**\n * @param token A token that represents a dependency that should be injected.\n * @param options Control how injection is executed. Options correspond to injection strategies\n *     that can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and\n *     `@Optional`.\n * @returns the injected value if operation is successful.\n * @throws if called outside of a supported context, or if the token is not found.\n *\n * @publicApi\n */\nexport function inject<T>(token: ProviderToken<T>, options: InjectOptions&{optional?: false}): T;\n/**\n * @param token A token that represents a dependency that should be injected.\n * @param options Control how injection is executed. Options correspond to injection strategies\n *     that can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and\n *     `@Optional`.\n * @returns the injected value if operation is successful,  `null` if the token is not\n *     found and optional injection has been requested.\n * @throws if called outside of a supported context, or if the token is not found and optional\n *     injection was not requested.\n *\n * @publicApi\n */\nexport function inject<T>(token: ProviderToken<T>, options: InjectOptions): T|null;\n/**\n * Injects a token from the currently active injector.\n * `inject` is only supported during instantiation of a dependency by the DI system. It can be used\n * during:\n * - Construction (via the `constructor`) of a class being instantiated by the DI system, such\n * as an `@Injectable` or `@Component`.\n * - In the initializer for fields of such classes.\n * - In the factory function specified for `useFactory` of a `Provider` or an `@Injectable`.\n * - In the `factory` function specified for an `InjectionToken`.\n *\n * @param token A token that represents a dependency that should be injected.\n * @param flags Optional flags that control how injection is executed.\n * The flags correspond to injection strategies that can be specified with\n * parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.\n * @returns the injected value if operation is successful, `null` otherwise.\n * @throws if called outside of a supported context.\n *\n * @usageNotes\n * In practice the `inject()` calls are allowed in a constructor, a constructor parameter and a\n * field initializer:\n *\n * ```typescript\n * @Injectable({providedIn: 'root'})\n * export class Car {\n *   radio: Radio|undefined;\n *   // OK: field initializer\n *   spareTyre = inject(Tyre);\n *\n *   constructor() {\n *     // OK: constructor body\n *     this.radio = inject(Radio);\n *   }\n * }\n * ```\n *\n * It is also legal to call `inject` from a provider's factory:\n *\n * ```typescript\n * providers: [\n *   {provide: Car, useFactory: () => {\n *     // OK: a class factory\n *     const engine = inject(Engine);\n *     return new Car(engine);\n *   }}\n * ]\n * ```\n *\n * Calls to the `inject()` function outside of the class creation context will result in error. Most\n * notably, calls to `inject()` are disallowed after a class instance was created, in methods\n * (including lifecycle hooks):\n *\n * ```typescript\n * @Component({ ... })\n * export class CarComponent {\n *   ngOnInit() {\n *     // ERROR: too late, the component instance was already created\n *     const engine = inject(Engine);\n *     engine.start();\n *   }\n * }\n * ```\n *\n * @publicApi\n */\nexport function inject<T>(\n    token: ProviderToken<T>, flags: InjectFlags|InjectOptions = InjectFlags.Default): T|null {\n  return ɵɵinject(token, convertToBitFlags(flags));\n}\n\n// Converts object-based DI flags (`InjectOptions`) to bit flags (`InjectFlags`).\nexport function convertToBitFlags(flags: InjectOptions|InjectFlags|undefined): InjectFlags|\n    undefined {\n  if (typeof flags === 'undefined' || typeof flags === 'number') {\n    return flags;\n  }\n\n  // While TypeScript doesn't accept it without a cast, bitwise OR with false-y values in\n  // JavaScript is a no-op. We can use that for a very codesize-efficient conversion from\n  // `InjectOptions` to `InjectFlags`.\n  return (InternalInjectFlags.Default |  // comment to force a line break in the formatter\n          ((flags.optional && InternalInjectFlags.Optional) as number) |\n          ((flags.host && InternalInjectFlags.Host) as number) |\n          ((flags.self && InternalInjectFlags.Self) as number) |\n          ((flags.skipSelf && InternalInjectFlags.SkipSelf) as number)) as InjectFlags;\n}\n\nexport function injectArgs(types: (ProviderToken<any>|any[])[]): any[] {\n  const args: any[] = [];\n  for (let i = 0; i < types.length; i++) {\n    const arg = resolveForwardRef(types[i]);\n    if (Array.isArray(arg)) {\n      if (arg.length === 0) {\n        throw new RuntimeError(\n            RuntimeErrorCode.INVALID_DIFFER_INPUT,\n            ngDevMode && 'Arguments array must have arguments.');\n      }\n      let type: Type<any>|undefined = undefined;\n      let flags: InjectFlags = InjectFlags.Default;\n\n      for (let j = 0; j < arg.length; j++) {\n        const meta = arg[j];\n        const flag = getInjectFlag(meta);\n        if (typeof flag === 'number') {\n          // Special case when we handle @Inject decorator.\n          if (flag === DecoratorFlags.Inject) {\n            type = meta.token;\n          } else {\n            flags |= flag;\n          }\n        } else {\n          type = meta;\n        }\n      }\n\n      args.push(ɵɵinject(type!, flags));\n    } else {\n      args.push(ɵɵinject(arg));\n    }\n  }\n  return args;\n}\n\n/**\n * Attaches a given InjectFlag to a given decorator using monkey-patching.\n * Since DI decorators can be used in providers `deps` array (when provider is configured using\n * `useFactory`) without initialization (e.g. `Host`) and as an instance (e.g. `new Host()`), we\n * attach the flag to make it available both as a static property and as a field on decorator\n * instance.\n *\n * @param decorator Provided DI decorator.\n * @param flag InjectFlag that should be applied.\n */\nexport function attachInjectFlag(decorator: any, flag: InternalInjectFlags|DecoratorFlags): any {\n  decorator[DI_DECORATOR_FLAG] = flag;\n  decorator.prototype[DI_DECORATOR_FLAG] = flag;\n  return decorator;\n}\n\n/**\n * Reads monkey-patched property that contains InjectFlag attached to a decorator.\n *\n * @param token Token that may contain monkey-patched DI flags property.\n */\nexport function getInjectFlag(token: any): number|undefined {\n  return token[DI_DECORATOR_FLAG];\n}\n\nexport function catchInjectorError(\n    e: any, token: any, injectorErrorName: string, source: string|null): never {\n  const tokenPath: any[] = e[NG_TEMP_TOKEN_PATH];\n  if (token[SOURCE]) {\n    tokenPath.unshift(token[SOURCE]);\n  }\n  e.message = formatError('\\n' + e.message, tokenPath, injectorErrorName, source);\n  e[NG_TOKEN_PATH] = tokenPath;\n  e[NG_TEMP_TOKEN_PATH] = null;\n  throw e;\n}\n\nexport function formatError(\n    text: string, obj: any, injectorErrorName: string, source: string|null = null): string {\n  text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.slice(2) : text;\n  let context = stringify(obj);\n  if (Array.isArray(obj)) {\n    context = obj.map(stringify).join(' -> ');\n  } else if (typeof obj === 'object') {\n    let parts = <string[]>[];\n    for (let key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        let value = obj[key];\n        parts.push(\n            key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n      }\n    }\n    context = `{${parts.join(', ')}}`;\n  }\n  return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${\n      text.replace(NEW_LINE, '\\n  ')}`;\n}\n"]}

package/esm2022/src/di/provider_collection.mjs

@@ -0,0 +1,279 @@
+/**
+ * @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 { RuntimeError } from '../errors';
+import { getComponentDef } from '../render3/definition';
+import { getFactoryDef } from '../render3/definition_factory';
+import { throwCyclicDependencyError, throwInvalidProviderError } from '../render3/errors_di';
+import { stringifyForError } from '../render3/util/stringify_utils';
+import { deepForEach } from '../util/array_utils';
+import { EMPTY_ARRAY } from '../util/empty';
+import { getClosureSafeProperty } from '../util/property';
+import { stringify } from '../util/stringify';
+import { resolveForwardRef } from './forward_ref';
+import { ENVIRONMENT_INITIALIZER } from './initializer_token';
+import { ɵɵinject as inject } from './injector_compatibility';
+import { getInjectorDef } from './interface/defs';
+import { isEnvironmentProviders } from './interface/provider';
+import { INJECTOR_DEF_TYPES } from './internal_tokens';
+/**
+ * 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;
+    deepForEach(sources, source => {
+        if ((typeof ngDevMode === 'undefined' || ngDevMode) && checkForStandaloneCmp) {
+            const cmpDef = getComponentDef(source);
+            if (cmpDef?.standalone) {
+                throw new RuntimeError(800 /* RuntimeErrorCode.IMPORT_PROVIDERS_FROM_STANDALONE */, `Importing providers supports NgModule or ModuleWithProviders but got a standalone component "${stringifyForError(source)}"`);
+            }
+        }
+        // Narrow `source` to access the internal type analogue for `ModuleWithProviders`.
+        const internalSource = source;
+        if (walkProviderTree(internalSource, providersOut, [], dedup)) {
+            injectorTypesWithProviders ||= [];
+            injectorTypesWithProviders.push(internalSource);
+        }
+    });
+    // Collect all providers from `ModuleWithProviders` types.
+    if (injectorTypesWithProviders !== undefined) {
+        processInjectorTypesWithProviders(injectorTypesWithProviders, providersOut);
+    }
+    return providersOut;
+}
+/**
+ * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided
+ * array.
+ */
+function processInjectorTypesWithProviders(typesWithProviders, providersOut) {
+    for (let i = 0; i < typesWithProviders.length; i++) {
+        const { ngModule, providers } = typesWithProviders[i];
+        deepForEachProvider(providers, provider => {
+            ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
+            providersOut.push(provider);
+        });
+    }
+}
+/**
+ * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone
+ * `ComponentType`, and all of its transitive providers and collects providers.
+ *
+ * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,
+ * the function will return "true" to indicate that the providers of the type definition need
+ * to be processed. This allows us to process providers of injector types after all imports of
+ * an injector definition are processed. (following View Engine semantics: see FW-1349)
+ */
+export function walkProviderTree(container, providersOut, parents, dedup) {
+    container = resolveForwardRef(container);
+    if (!container)
+        return false;
+    // The actual type which had the definition. Usually `container`, but may be an unwrapped type
+    // from `InjectorTypeWithProviders`.
+    let defType = null;
+    let injDef = getInjectorDef(container);
+    const cmpDef = !injDef && getComponentDef(container);
+    if (!injDef && !cmpDef) {
+        // `container` is not an injector type or a component type. It might be:
+        //  * An `InjectorTypeWithProviders` that wraps an injector type.
+        //  * A standalone directive or pipe that got pulled in from a standalone component's
+        //    dependencies.
+        // Try to unwrap it as an `InjectorTypeWithProviders` first.
+        const ngModule = container.ngModule;
+        injDef = getInjectorDef(ngModule);
+        if (injDef) {
+            defType = ngModule;
+        }
+        else {
+            // Not a component or injector type, so ignore it.
+            return false;
+        }
+    }
+    else if (cmpDef && !cmpDef.standalone) {
+        return false;
+    }
+    else {
+        defType = container;
+    }
+    // Check for circular dependencies.
+    if (ngDevMode && parents.indexOf(defType) !== -1) {
+        const defName = stringify(defType);
+        const path = parents.map(stringify);
+        throwCyclicDependencyError(defName, path);
+    }
+    // Check for multiple imports of the same module
+    const isDuplicate = dedup.has(defType);
+    if (cmpDef) {
+        if (isDuplicate) {
+            // This component definition has already been processed.
+            return false;
+        }
+        dedup.add(defType);
+        if (cmpDef.dependencies) {
+            const deps = typeof cmpDef.dependencies === 'function' ? cmpDef.dependencies() : cmpDef.dependencies;
+            for (const dep of deps) {
+                walkProviderTree(dep, providersOut, parents, dedup);
+            }
+        }
+    }
+    else if (injDef) {
+        // First, include providers from any imports.
+        if (injDef.imports != null && !isDuplicate) {
+            // Before processing defType's imports, add it to the set of parents. This way, if it ends
+            // up deeply importing itself, this can be detected.
+            ngDevMode && parents.push(defType);
+            // Add it to the set of dedups. This way we can detect multiple imports of the same module
+            dedup.add(defType);
+            let importTypesWithProviders;
+            try {
+                deepForEach(injDef.imports, imported => {
+                    if (walkProviderTree(imported, providersOut, parents, dedup)) {
+                        importTypesWithProviders ||= [];
+                        // If the processed import is an injector type with providers, we store it in the
+                        // list of import types with providers, so that we can process those afterwards.
+                        importTypesWithProviders.push(imported);
+                    }
+                });
+            }
+            finally {
+                // Remove it from the parents set when finished.
+                ngDevMode && parents.pop();
+            }
+            // Imports which are declared with providers (TypeWithProviders) need to be processed
+            // after all imported modules are processed. This is similar to how View Engine
+            // processes/merges module imports in the metadata resolver. See: FW-1349.
+            if (importTypesWithProviders !== undefined) {
+                processInjectorTypesWithProviders(importTypesWithProviders, providersOut);
+            }
+        }
+        if (!isDuplicate) {
+            // Track the InjectorType and add a provider for it.
+            // It's important that this is done after the def's imports.
+            const factory = getFactoryDef(defType) || (() => new defType());
+            // Append extra providers to make more info available for consumers (to retrieve an injector
+            // type), as well as internally (to calculate an injection scope correctly and eagerly
+            // instantiate a `defType` when an injector is created).
+            providersOut.push(
+            // Provider to create `defType` using its factory.
+            { provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, 
+            // Make this `defType` available to an internal logic that calculates injector scope.
+            { provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, 
+            // Provider to eagerly instantiate `defType` via `ENVIRONMENT_INITIALIZER`.
+            { provide: ENVIRONMENT_INITIALIZER, useValue: () => inject(defType), multi: true } //
+            );
+        }
+        // Next, include providers listed on the definition itself.
+        const defProviders = injDef.providers;
+        if (defProviders != null && !isDuplicate) {
+            const injectorType = container;
+            deepForEachProvider(defProviders, provider => {
+                ngDevMode && validateProvider(provider, defProviders, injectorType);
+                providersOut.push(provider);
+            });
+        }
+    }
+    else {
+        // Should not happen, but just in case.
+        return false;
+    }
+    return (defType !== container &&
+        container.providers !== undefined);
+}
+function validateProvider(provider, providers, containerType) {
+    if (isTypeProvider(provider) || isValueProvider(provider) || isFactoryProvider(provider) ||
+        isExistingProvider(provider)) {
+        return;
+    }
+    // Here we expect the provider to be a `useClass` provider (by elimination).
+    const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
+    if (!classRef) {
+        throwInvalidProviderError(containerType, providers, provider);
+    }
+}
+function deepForEachProvider(providers, fn) {
+    for (let provider of providers) {
+        if (isEnvironmentProviders(provider)) {
+            provider = provider.ɵproviders;
+        }
+        if (Array.isArray(provider)) {
+            deepForEachProvider(provider, fn);
+        }
+        else {
+            fn(provider);
+        }
+    }
+}
+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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider_collection.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/di/provider_collection.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {Type} from '../interface/type';\nimport {getComponentDef} from '../render3/definition';\nimport {getFactoryDef} from '../render3/definition_factory';\nimport {throwCyclicDependencyError, throwInvalidProviderError} from '../render3/errors_di';\nimport {stringifyForError} from '../render3/util/stringify_utils';\nimport {deepForEach} from '../util/array_utils';\nimport {EMPTY_ARRAY} from '../util/empty';\nimport {getClosureSafeProperty} from '../util/property';\nimport {stringify} from '../util/stringify';\n\nimport {resolveForwardRef} from './forward_ref';\nimport {ENVIRONMENT_INITIALIZER} from './initializer_token';\nimport {ɵɵinject as inject} from './injector_compatibility';\nimport {getInjectorDef, InjectorType, InjectorTypeWithProviders} from './interface/defs';\nimport {ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, ImportedNgModuleProviders, InternalEnvironmentProviders, isEnvironmentProviders, ModuleWithProviders, Provider, StaticClassProvider, TypeProvider, ValueProvider} from './interface/provider';\nimport {INJECTOR_DEF_TYPES} from './internal_tokens';\n\n/**\n * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally\n * referenced in `@Component in a component injector.\n */\nexport function makeEnvironmentProviders(providers: (Provider|EnvironmentProviders)[]):\n    EnvironmentProviders {\n  return {\n    ɵproviders: providers,\n  } as unknown as EnvironmentProviders;\n}\n\n/**\n * A source of providers for the `importProvidersFrom` function.\n *\n * @publicApi\n */\nexport type ImportProvidersSource =\n    Type<unknown>|ModuleWithProviders<unknown>|Array<ImportProvidersSource>;\n\n/**\n * Collects providers from all NgModules and standalone components, including transitively imported\n * ones.\n *\n * Providers extracted via `importProvidersFrom` are only usable in an application injector or\n * another environment injector (such as a route injector). They should not be used in component\n * providers.\n *\n * More information about standalone components can be found in [this\n * guide](guide/standalone-components).\n *\n * @usageNotes\n * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:\n *\n * ```typescript\n * await bootstrapApplication(RootComponent, {\n *   providers: [\n *     importProvidersFrom(NgModuleOne, NgModuleTwo)\n *   ]\n * });\n * ```\n *\n * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a\n * standalone component is used:\n *\n * ```typescript\n * export const ROUTES: Route[] = [\n *   {\n *     path: 'foo',\n *     providers: [\n *       importProvidersFrom(NgModuleOne, NgModuleTwo)\n *     ],\n *     component: YourStandaloneComponent\n *   }\n * ];\n * ```\n *\n * @returns Collected providers from the specified list of types.\n * @publicApi\n */\nexport function importProvidersFrom(...sources: ImportProvidersSource[]): EnvironmentProviders {\n  return {\n    ɵproviders: internalImportProvidersFrom(true, sources),\n    ɵfromNgModule: true,\n  } as InternalEnvironmentProviders;\n}\n\nexport function internalImportProvidersFrom(\n    checkForStandaloneCmp: boolean, ...sources: ImportProvidersSource[]): Provider[] {\n  const providersOut: SingleProvider[] = [];\n  const dedup = new Set<Type<unknown>>();  // already seen types\n  let injectorTypesWithProviders: InjectorTypeWithProviders<unknown>[]|undefined;\n  deepForEach(sources, source => {\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && checkForStandaloneCmp) {\n      const cmpDef = getComponentDef(source);\n      if (cmpDef?.standalone) {\n        throw new RuntimeError(\n            RuntimeErrorCode.IMPORT_PROVIDERS_FROM_STANDALONE,\n            `Importing providers supports NgModule or ModuleWithProviders but got a standalone component \"${\n                stringifyForError(source)}\"`);\n      }\n    }\n\n    // Narrow `source` to access the internal type analogue for `ModuleWithProviders`.\n    const internalSource = source as Type<unknown>| InjectorTypeWithProviders<unknown>;\n    if (walkProviderTree(internalSource, providersOut, [], dedup)) {\n      injectorTypesWithProviders ||= [];\n      injectorTypesWithProviders.push(internalSource);\n    }\n  });\n  // Collect all providers from `ModuleWithProviders` types.\n  if (injectorTypesWithProviders !== undefined) {\n    processInjectorTypesWithProviders(injectorTypesWithProviders, providersOut);\n  }\n\n  return providersOut;\n}\n\n/**\n * Collects all providers from the list of `ModuleWithProviders` and appends them to the provided\n * array.\n */\nfunction processInjectorTypesWithProviders(\n    typesWithProviders: InjectorTypeWithProviders<unknown>[], providersOut: Provider[]): void {\n  for (let i = 0; i < typesWithProviders.length; i++) {\n    const {ngModule, providers} = typesWithProviders[i];\n    deepForEachProvider(providers! as Array<Provider|InternalEnvironmentProviders>, provider => {\n      ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);\n      providersOut.push(provider);\n    });\n  }\n}\n\n/**\n * Internal type for a single provider in a deep provider array.\n */\nexport type SingleProvider = TypeProvider|ValueProvider|ClassProvider|ConstructorProvider|\n    ExistingProvider|FactoryProvider|StaticClassProvider;\n\n/**\n * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone\n * `ComponentType`, and all of its transitive providers and collects providers.\n *\n * If an `InjectorTypeWithProviders` that declares providers besides the type is specified,\n * the function will return \"true\" to indicate that the providers of the type definition need\n * to be processed. This allows us to process providers of injector types after all imports of\n * an injector definition are processed. (following View Engine semantics: see FW-1349)\n */\nexport function walkProviderTree(\n    container: Type<unknown>|InjectorTypeWithProviders<unknown>, providersOut: SingleProvider[],\n    parents: Type<unknown>[],\n    dedup: Set<Type<unknown>>): container is InjectorTypeWithProviders<unknown> {\n  container = resolveForwardRef(container);\n  if (!container) return false;\n\n  // The actual type which had the definition. Usually `container`, but may be an unwrapped type\n  // from `InjectorTypeWithProviders`.\n  let defType: Type<unknown>|null = null;\n\n  let injDef = getInjectorDef(container);\n  const cmpDef = !injDef && getComponentDef(container);\n  if (!injDef && !cmpDef) {\n    // `container` is not an injector type or a component type. It might be:\n    //  * An `InjectorTypeWithProviders` that wraps an injector type.\n    //  * A standalone directive or pipe that got pulled in from a standalone component's\n    //    dependencies.\n    // Try to unwrap it as an `InjectorTypeWithProviders` first.\n    const ngModule: Type<unknown>|undefined =\n        (container as InjectorTypeWithProviders<any>).ngModule as Type<unknown>| undefined;\n    injDef = getInjectorDef(ngModule);\n    if (injDef) {\n      defType = ngModule!;\n    } else {\n      // Not a component or injector type, so ignore it.\n      return false;\n    }\n  } else if (cmpDef && !cmpDef.standalone) {\n    return false;\n  } else {\n    defType = container as Type<unknown>;\n  }\n\n  // Check for circular dependencies.\n  if (ngDevMode && parents.indexOf(defType) !== -1) {\n    const defName = stringify(defType);\n    const path = parents.map(stringify);\n    throwCyclicDependencyError(defName, path);\n  }\n\n  // Check for multiple imports of the same module\n  const isDuplicate = dedup.has(defType);\n\n  if (cmpDef) {\n    if (isDuplicate) {\n      // This component definition has already been processed.\n      return false;\n    }\n    dedup.add(defType);\n\n    if (cmpDef.dependencies) {\n      const deps =\n          typeof cmpDef.dependencies === 'function' ? cmpDef.dependencies() : cmpDef.dependencies;\n      for (const dep of deps) {\n        walkProviderTree(dep, providersOut, parents, dedup);\n      }\n    }\n  } else if (injDef) {\n    // First, include providers from any imports.\n    if (injDef.imports != null && !isDuplicate) {\n      // Before processing defType's imports, add it to the set of parents. This way, if it ends\n      // up deeply importing itself, this can be detected.\n      ngDevMode && parents.push(defType);\n      // Add it to the set of dedups. This way we can detect multiple imports of the same module\n      dedup.add(defType);\n\n      let importTypesWithProviders: (InjectorTypeWithProviders<any>[])|undefined;\n      try {\n        deepForEach(injDef.imports, imported => {\n          if (walkProviderTree(imported, providersOut, parents, dedup)) {\n            importTypesWithProviders ||= [];\n            // If the processed import is an injector type with providers, we store it in the\n            // list of import types with providers, so that we can process those afterwards.\n            importTypesWithProviders.push(imported);\n          }\n        });\n      } finally {\n        // Remove it from the parents set when finished.\n        ngDevMode && parents.pop();\n      }\n\n      // Imports which are declared with providers (TypeWithProviders) need to be processed\n      // after all imported modules are processed. This is similar to how View Engine\n      // processes/merges module imports in the metadata resolver. See: FW-1349.\n      if (importTypesWithProviders !== undefined) {\n        processInjectorTypesWithProviders(importTypesWithProviders, providersOut);\n      }\n    }\n\n    if (!isDuplicate) {\n      // Track the InjectorType and add a provider for it.\n      // It's important that this is done after the def's imports.\n      const factory = getFactoryDef(defType) || (() => new defType!());\n\n      // Append extra providers to make more info available for consumers (to retrieve an injector\n      // type), as well as internally (to calculate an injection scope correctly and eagerly\n      // instantiate a `defType` when an injector is created).\n      providersOut.push(\n          // Provider to create `defType` using its factory.\n          {provide: defType, useFactory: factory, deps: EMPTY_ARRAY},\n\n          // Make this `defType` available to an internal logic that calculates injector scope.\n          {provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true},\n\n          // Provider to eagerly instantiate `defType` via `ENVIRONMENT_INITIALIZER`.\n          {provide: ENVIRONMENT_INITIALIZER, useValue: () => inject(defType!), multi: true}  //\n      );\n    }\n\n    // Next, include providers listed on the definition itself.\n    const defProviders = injDef.providers as Array<SingleProvider|InternalEnvironmentProviders>;\n    if (defProviders != null && !isDuplicate) {\n      const injectorType = container as InjectorType<any>;\n      deepForEachProvider(defProviders, provider => {\n        ngDevMode && validateProvider(provider as SingleProvider, defProviders, injectorType);\n        providersOut.push(provider as SingleProvider);\n      });\n    }\n  } else {\n    // Should not happen, but just in case.\n    return false;\n  }\n\n  return (\n      defType !== container &&\n      (container as InjectorTypeWithProviders<any>).providers !== undefined);\n}\n\nfunction validateProvider(\n    provider: SingleProvider, providers: Array<SingleProvider|InternalEnvironmentProviders>,\n    containerType: Type<unknown>): void {\n  if (isTypeProvider(provider) || isValueProvider(provider) || isFactoryProvider(provider) ||\n      isExistingProvider(provider)) {\n    return;\n  }\n\n  // Here we expect the provider to be a `useClass` provider (by elimination).\n  const classRef = resolveForwardRef(\n      provider && ((provider as StaticClassProvider | ClassProvider).useClass || provider.provide));\n  if (!classRef) {\n    throwInvalidProviderError(containerType, providers, provider);\n  }\n}\n\nfunction deepForEachProvider(\n    providers: Array<Provider|InternalEnvironmentProviders>,\n    fn: (provider: SingleProvider) => void): void {\n  for (let provider of providers) {\n    if (isEnvironmentProviders(provider)) {\n      provider = provider.ɵproviders;\n    }\n    if (Array.isArray(provider)) {\n      deepForEachProvider(provider, fn);\n    } else {\n      fn(provider);\n    }\n  }\n}\n\nexport const USE_VALUE =\n    getClosureSafeProperty<ValueProvider>({provide: String, useValue: getClosureSafeProperty});\n\nexport function isValueProvider(value: SingleProvider): value is ValueProvider {\n  return value !== null && typeof value == 'object' && USE_VALUE in value;\n}\n\nexport function isExistingProvider(value: SingleProvider): value is ExistingProvider {\n  return !!(value && (value as ExistingProvider).useExisting);\n}\n\nexport function isFactoryProvider(value: SingleProvider): value is FactoryProvider {\n  return !!(value && (value as FactoryProvider).useFactory);\n}\n\nexport function isTypeProvider(value: SingleProvider): value is TypeProvider {\n  return typeof value === 'function';\n}\n\nexport function isClassProvider(value: SingleProvider): value is ClassProvider {\n  return !!(value as StaticClassProvider | ClassProvider).useClass;\n}\n"]}