static-injector 2.1.0 → 2.2.0

package/import/typings/di/create_injector.d.ts

@@ -6,18 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Injector } from './injector';
-import { StaticProvider } from './interface/provider';
+import { Provider, StaticProvider } from './interface/provider';
 import { R3Injector } from './r3_injector';
 import { InjectorScope } from './scope';
 /**
  * Create a new `Injector` which is configured using a `defType` of `InjectorType<any>`s.
- *
- * @publicApi
  */
-export declare function createInjector(defType: any, parent?: Injector | null, additionalProviders?: StaticProvider[] | null, name?: string): Injector;
+export declare function createInjector(defType: any, parent?: Injector | null, additionalProviders?: Array<Provider | StaticProvider> | null, name?: string): Injector;
 /**
  * Creates a new injector without eagerly resolving its injector types. Can be used in places
  * where resolving the injector types immediately can lead to an infinite loop. The injector types
  * should be resolved at a later point by calling `_resolveInjectorDefTypes`.
  */
-export declare function createInjectorWithoutInjectorInstances(defType: any, parent?: Injector | null, additionalProviders?: StaticProvider[] | null, name?: string, scopes?: Set<InjectorScope>): R3Injector;
+export declare function createInjectorWithoutInjectorInstances(defType: any, parent?: Injector | null, additionalProviders?: Array<Provider | StaticProvider> | null, name?: string, scopes?: Set<InjectorScope>): R3Injector;

package/import/typings/di/forward_ref.d.ts

@@ -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 { Type } from "../interface/type";
+import { Type } from '../interface/type';
 /**
  * An interface that a function passed into {@link forwardRef} has to implement.
  *
@@ -25,9 +25,36 @@ export interface ForwardRefFn {
  * 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 declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;
@@ -41,7 +68,7 @@ export declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;
  *
  * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
  *
- * @see `forwardRef`
+ * @see {@link forwardRef}
  * @publicApi
  */
 export declare function resolveForwardRef<T>(type: T): T;

package/import/typings/di/inject_switch.d.ts

@@ -7,7 +7,7 @@
  */
 import { InjectFlags } from './interface/injector';
 import { ProviderToken } from './provider_token';
-export declare function getInjectImplementation(): <T>(token: ProviderToken<T>, flags?: InjectFlags) => T;
+export declare function getInjectImplementation(): (<T>(token: ProviderToken<T>, flags?: InjectFlags | undefined) => T | null) | undefined;
 /**
  * Sets the current inject implementation.
  */

package/import/typings/di/injectable.d.ts

@@ -5,9 +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 { ValueSansProvider, ExistingSansProvider, StaticClassSansProvider, ConstructorSansProvider, FactorySansProvider, ClassSansProvider } from './interface/provider';
 import { Type } from '../interface/type';
 import { TypeDecorator } from '../util/decorators';
+import { ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueSansProvider } from './interface/provider';
 /**
  * Injectable providers used in `@Injectable` decorator.
  *
@@ -57,7 +57,8 @@ export interface Injectable {
     /**
      * Determines which injectors will provide the injectable.
      *
-     * - `Type<any>` - associates the injectable with an `@NgModule` or other `InjectorType`,
+     * - `Type<any>` - associates the injectable with an `@NgModule` or other `InjectorType`. This
+     * option is DEPRECATED.
      * - 'null' : Equivalent to `undefined`. The injectable is not provided in any scope automatically
      * and must be added to a `providers` array of an [@NgModule](api/core/NgModule#providers),
      * [@Component](api/core/Directive#providers) or [@Directive](api/core/Directive#providers).
@@ -68,7 +69,7 @@ export interface Injectable {
      * - 'platform' : A special singleton platform injector shared by all
      * applications on the page.
      * - 'any' : Provides a unique instance in each lazy loaded module while all eagerly loaded
-     * modules share one instance.
+     * modules share one instance. This option is DEPRECATED.
      *
      */
     providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;

package/import/typings/di/injection_token.d.ts

@@ -14,11 +14,11 @@ import { Type } from '../interface/type';
  * 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 { Type } from '../interface/type';
  * (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
  *
@@ -48,7 +52,15 @@ import { Type } from '../interface/type';
  */
 export declare class InjectionToken<T> {
     protected _desc: string;
+    /** @internal */
+    readonly ngMetadataName = "InjectionToken";
     readonly ɵprov: unknown;
+    /**
+     * @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: string, options?: {
         providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
         factory: () => T;
@@ -59,3 +71,6 @@ export declare class InjectionToken<T> {
     get multi(): InjectionToken<Array<T>>;
     toString(): string;
 }
+export interface InjectableDefToken<T> extends InjectionToken<T> {
+    ɵprov: unknown;
+}

package/import/typings/di/injector.d.ts

@@ -7,7 +7,7 @@
  */
 import { InjectorMarkers } from './injector_marker';
 import { InjectFlags, InjectOptions } from './interface/injector';
-import { StaticProvider } from './interface/provider';
+import { Provider, StaticProvider } from './interface/provider';
 import { ProviderToken } from './provider_token';
 /**
  * Concrete injectors implement this interface. Injectors are configured
@@ -15,7 +15,7 @@ import { ProviderToken } from './provider_token';
  * dependencies of various types with [injection tokens](guide/glossary#di-token).
  *
  * @see ["DI Providers"](guide/dependency-injection-providers).
- * @see `StaticProvider`
+ * @see {@link StaticProvider}
  *
  * @usageNotes
  *
@@ -62,6 +62,22 @@ export declare abstract class Injector {
      * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
      */
     abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions | InjectFlags): T;
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     * @deprecated use object-based flags (`InjectOptions`) instead.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    /**
+     * @deprecated from v4.0.0 use ProviderToken<T>
+     * @suppress {duplicate}
+     */
+    abstract get(token: any, notFoundValue?: any): any;
+    /**
+     * @deprecated from v5 use the new signature Injector.create(options)
+     */
+    static create(providers: StaticProvider[], parent?: Injector): Injector;
     /**
      * Creates a new injector instance that provides one or more dependencies,
      * according to a given type or types of `StaticProvider`.
@@ -75,7 +91,7 @@ export declare abstract class Injector {
      *
      */
     static create(options: {
-        providers: StaticProvider[];
+        providers: Array<Provider | StaticProvider>;
         parent?: Injector;
         name?: string;
     }): Injector;

package/import/typings/di/injector_compatibility.d.ts

@@ -11,15 +11,12 @@ import { ProviderToken } from './provider_token';
 export declare const THROW_IF_NOT_FOUND: {};
 export declare const NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
 export declare const SOURCE = "__source";
-export declare const USE_VALUE: string;
+export declare function getCurrentInjector(): Injector | undefined | null;
 export declare function setCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null;
 export declare function injectInjectorOnly<T>(token: ProviderToken<T>): T;
 export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
 /**
- * Generated instruction: Injects a token from the currently active injector.
- *
- * Must be used in the context of a factory function such as one defined for an
- * `InjectionToken`. Throws an error if not called from such a context.
+ * Generated instruction: injects a token from the currently active injector.
  *
  * (Additional documentation moved to `inject`, as it is the public API, and an alias for this
  * instruction)
@@ -30,6 +27,16 @@ export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: I
  */
 export declare function ɵɵinject<T>(token: ProviderToken<T>): T;
 export declare function ɵɵinject<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
+/**
+ * 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 declare function ɵɵinvalidFactoryDep(index: number): void;
 /**
  * @param token A token that represents a dependency that should be injected.
  * @returns the injected value if operation is successful, `null` otherwise.

package/import/typings/di/injector_token.d.ts

@@ -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 { InjectionToken } from "./injection_token";
-import { Injector } from "./injector";
+import { InjectionToken } from './injection_token';
+import { Injector } from './injector';
 /**
  * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.
  *

package/import/typings/di/interface/defs.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Type } from '../../interface/type';
-import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, ValueProvider } from './provider';
+import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, StaticClassProvider, ValueProvider } from './provider';
 /**
  * Information about how a type or `InjectionToken` interfaces with the DI system.
  *
@@ -31,7 +31,7 @@ export interface ɵɵInjectableDeclaration<T> {
      * - `null`, does not belong to any injector. Must be explicitly listed in the injector
      *   `providers`.
      */
-    providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | null;
+    providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | 'environment' | null;
     /**
      * The token to which this definition belongs.
      *
@@ -60,14 +60,14 @@ export interface ɵɵInjectableDeclaration<T> {
  * @codeGenApi
  */
 export interface ɵɵInjectorDef<T> {
-    providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
+    providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | EnvironmentProviders | any[])[];
     imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
 }
 /**
  * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.
  *
  * `InjectableType`s contain their own Dependency Injection metadata and are usable in an
- * `InjectorDef`-based `StaticInjector.
+ * `InjectorDef`-based `StaticInjector`.
  *
  * @publicApi
  */
@@ -100,7 +100,7 @@ export interface InjectorType<T> extends Type<T> {
  */
 export interface InjectorTypeWithProviders<T> {
     ngModule: InjectorType<T>;
-    providers?: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
+    providers?: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | EnvironmentProviders | any[])[];
 }
 /**
  * Construct an injectable definition which defines how a token will be constructed by the DI
@@ -114,14 +114,15 @@ export interface InjectorTypeWithProviders<T> {
  *   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.
  */
 export declare function ɵɵdefineInjectable<T>(opts: {
     token: unknown;
-    providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
+    providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null;
     factory: () => T;
 }): unknown;
 /**
@@ -152,7 +153,7 @@ export declare function ɵɵdefineInjector(options: {
  * @param type A type which may have its own (non-inherited) `ɵprov`.
  */
 export declare function getInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
-export declare const NG_PROV_DEF: string;
+export declare function isInjectable(type: any): boolean;
 /**
  * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
  *
@@ -162,4 +163,11 @@ export declare const NG_PROV_DEF: string;
  *     scenario if we find the `ɵprov` on an ancestor only.
  */
 export declare function getInheritedInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
-export declare const NG_INJECTABLE_DEF: string;
+/**
+ * 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 declare function getInjectorDef<T>(type: any): ɵɵInjectorDef<T> | null;
+export declare const NG_PROV_DEF: string;
+export declare const NG_INJ_DEF: string;

package/import/typings/di/interface/injector.d.ts

@@ -17,7 +17,7 @@ export declare const enum DecoratorFlags {
  * 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 declare enum InjectFlags {
     /** Check self and check parent injector if needed */
@@ -48,7 +48,7 @@ export declare const enum InternalInjectFlags {
     Optional = 8
 }
 /**
- * Type of the options argument to `inject`.
+ * Type of the options argument to [`inject`](api/core/inject).
  *
  * @publicApi
  */

package/import/typings/di/interface/provider.d.ts

@@ -141,7 +141,7 @@ export interface ConstructorProvider extends ConstructorSansProvider {
 /**
  * Configures the `Injector` to return a value of another `useExisting` token.
  *
- * @see `ExistingProvider`
+ * @see {@link ExistingProvider}
  * @see ["Dependency Injection Guide"](guide/dependency-injection).
  *
  * @publicApi
@@ -181,7 +181,7 @@ export interface ExistingProvider extends ExistingSansProvider {
 /**
  * Configures the `Injector` to return a value by invoking a `useFactory` function.
  *
- * @see `FactoryProvider`
+ * @see {@link FactoryProvider}
  * @see ["Dependency Injection Guide"](guide/dependency-injection).
  *
  * @publicApi
@@ -231,7 +231,7 @@ export interface FactoryProvider extends FactorySansProvider {
  * Describes how an `Injector` should be configured as static (that is, without reflection).
  * A static provider provides tokens to an injector for various types of dependencies.
  *
- * @see `Injector.create()`.
+ * @see {@link Injector.create()}
  * @see ["Dependency Injection Guide"](guide/dependency-injection-providers).
  *
  * @publicApi
@@ -300,8 +300,68 @@ export interface ClassProvider extends ClassSansProvider {
  * Describes how the `Injector` should be configured.
  * @see ["Dependency Injection Guide"](guide/dependency-injection).
  *
- * @see `StaticProvider`
+ * @see {@link StaticProvider}
  *
  * @publicApi
  */
 export type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];
+/**
+ * Encapsulated `Provider`s that are only accepted during creation of an `EnvironmentInjector` (e.g.
+ * in an `NgModule`).
+ *
+ * Using this wrapper type prevents providers which are only designed to work in
+ * application/environment injectors from being accidentally included in
+ * `@Component.providers` and ending up in a component injector.
+ *
+ * This wrapper type prevents access to the `Provider`s inside.
+ *
+ * @see {@link makeEnvironmentProviders}
+ * @see {@link importProvidersFrom}
+ *
+ * @publicApi
+ */
+export type EnvironmentProviders = {
+    ɵbrand: 'EnvironmentProviders';
+};
+export interface InternalEnvironmentProviders extends EnvironmentProviders {
+    ɵproviders: (Provider | EnvironmentProviders)[];
+    /**
+     * If present, indicates that the `EnvironmentProviders` were derived from NgModule providers.
+     *
+     * This is used to produce clearer error messages.
+     */
+    ɵfromNgModule?: true;
+}
+export declare function isEnvironmentProviders(value: Provider | EnvironmentProviders | InternalEnvironmentProviders): value is InternalEnvironmentProviders;
+/**
+ * Describes a function that is used to process provider lists (such as provider
+ * overrides).
+ */
+export type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
+/**
+ * A wrapper around an NgModule that associates it with [providers](guide/glossary#provider
+ * "Definition"). Usage without a generic type is deprecated.
+ *
+ * @see [Deprecations](guide/deprecations#modulewithproviders-type-without-a-generic)
+ *
+ * @publicApi
+ */
+export interface ModuleWithProviders<T> {
+    ngModule: Type<T>;
+    providers?: Array<Provider | EnvironmentProviders>;
+}
+/**
+ * Providers that were imported from NgModules via the `importProvidersFrom` function.
+ *
+ * These providers are meant for use in an application injector (or other environment injectors) and
+ * should not be used in component injectors.
+ *
+ * This type cannot be directly implemented. It's returned from the `importProvidersFrom` function
+ * and serves to prevent the extracted NgModule providers from being used in the wrong contexts.
+ *
+ * @see {@link importProvidersFrom}
+ *
+ * @publicApi
+ * @deprecated replaced by `EnvironmentProviders`
+ */
+export type ImportedNgModuleProviders = EnvironmentProviders;

package/import/typings/di/metadata.d.ts

@@ -111,8 +111,8 @@ export interface SelfDecorator {
      * <code-example path="core/di/ts/metadata_spec.ts" region="Self">
      * </code-example>
      *
-     * @see `SkipSelf`
-     * @see `Optional`
+     * @see {@link SkipSelf}
+     * @see {@link Optional}
      *
      */
     (): any;
@@ -153,8 +153,8 @@ export interface SkipSelfDecorator {
      * </code-example>
      *
      * @see [Dependency Injection guide](guide/dependency-injection-in-action#skip).
-     * @see `Self`
-     * @see `Optional`
+     * @see {@link Self}
+     * @see {@link Optional}
      *
      */
     (): any;

package/import/typings/di/null_injector.d.ts

@@ -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 { Injector } from "./injector";
+import { Injector } from './injector';
 export declare class NullInjector implements Injector {
     get(token: any, notFoundValue?: any): any;
 }

package/import/typings/di/provider_collection.d.ts

@@ -6,22 +6,64 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Type } from '../interface/type';
-import { InjectorTypeWithProviders } from './interface/defs';
-import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
+import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, ModuleWithProviders, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
 /**
- * Internal type for a single provider in a deep provider array.
+ * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
+ * referenced in `@Component` in a component injector.
  */
-export type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+export declare function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders;
 /**
- * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone
- * `ComponentType`, and all of its transitive providers and collects providers.
+ * A source of providers for the `importProvidersFrom` function.
  *
- * 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)
+ * @publicApi
  */
-export declare function walkProviderTree(container: Type<unknown> | InjectorTypeWithProviders<unknown>, providersOut: SingleProvider[], parents: Type<unknown>[], dedup: Set<Type<unknown>>): container is InjectorTypeWithProviders<unknown>;
+export type ImportProvidersSource = Type<unknown> | ModuleWithProviders<unknown> | Array<ImportProvidersSource>;
+/**
+ * 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 declare function importProvidersFrom(...sources: ImportProvidersSource[]): EnvironmentProviders;
+export declare function internalImportProvidersFrom(checkForStandaloneCmp: boolean, ...sources: ImportProvidersSource[]): Provider[];
+/**
+ * Internal type for a single provider in a deep provider array.
+ */
+export type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
 export declare const USE_VALUE: string;
 export declare function isValueProvider(value: SingleProvider): value is ValueProvider;
 export declare function isExistingProvider(value: SingleProvider): value is ExistingProvider;

package/import/typings/di/provider_token.d.ts

@@ -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 { AbstractType, Type } from "../interface/type";
-import { InjectionToken } from "./injection_token";
+import { AbstractType, Type } from '../interface/type';
+import { InjectionToken } from './injection_token';
 /**
  * @description
  *