static-injector 1.0.8

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

@@ -0,0 +1,82 @@
+/**
+ * @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 { 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.
+ *
+ * @publicApi
+ */
+export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;
+/**
+ * Type of the Injectable decorator / constructor function.
+ *
+ * @publicApi
+ */
+export interface InjectableDecorator {
+    /**
+     * Decorator that marks a class as available to be
+     * provided and injected as a dependency.
+     *
+     * @see [Introduction to Services and DI](guide/architecture-services)
+     * @see [Dependency Injection Guide](guide/dependency-injection)
+     *
+     * @usageNotes
+     *
+     * Marking a class with `@Injectable` ensures that the compiler
+     * will generate the necessary metadata to create the class's
+     * dependencies when the class is injected.
+     *
+     * The following example shows how a service class is properly
+     *  marked so that a supporting service can be injected upon creation.
+     *
+     * <code-example path="core/di/ts/metadata_spec.ts" region="Injectable"></code-example>
+     *
+     */
+    (): TypeDecorator;
+    (options?: {
+        providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
+    } & InjectableProvider): TypeDecorator;
+    new (): Injectable;
+    new (options?: {
+        providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
+    } & InjectableProvider): Injectable;
+}
+/**
+ * Type of the Injectable metadata.
+ *
+ * @publicApi
+ */
+export interface Injectable {
+    /**
+     * Determines which injectors will provide the injectable.
+     *
+     * - `Type<any>` - associates the injectable with an `@NgModule` or other `InjectorType`,
+     * - '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).
+     *
+     * The following options specify that this injectable should be provided in one of the following
+     * injectors:
+     * - 'root' : The application-level injector in most apps.
+     * - '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.
+     *
+     */
+    providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
+}
+/**
+ * Injectable decorator and metadata.
+ *
+ * @Annotation
+ * @publicApi
+ */
+export declare const Injectable: InjectableDecorator;

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

@@ -0,0 +1,312 @@
+/**
+ * @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 { Type } from '../../interface/type';
+/**
+ * Configures the `Injector` to return a value for a token.
+ * Base for `ValueProvider` decorator.
+ *
+ * @publicApi
+ */
+export interface ValueSansProvider {
+    /**
+     * The value to inject.
+     */
+    useValue: any;
+}
+/**
+ * Configures the `Injector` to return a value for a token.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * ### Example
+ *
+ * {@example core/di/ts/provider_spec.ts region='ValueProvider'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ValueProvider extends ValueSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return an instance of `useClass` for a token.
+ * Base for `StaticClassProvider` decorator.
+ *
+ * @publicApi
+ */
+export interface StaticClassSansProvider {
+    /**
+     * An optional class to instantiate for the `token`. By default, the `provide`
+     * class is instantiated.
+     */
+    useClass: Type<any>;
+    /**
+     * A list of `token`s to be resolved by the injector. The list of values is then
+     * used as arguments to the `useClass` constructor.
+     */
+    deps: any[];
+}
+/**
+ * Configures the `Injector` to return an instance of `useClass` for a token.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='StaticClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ *
+ * {@example core/di/ts/provider_spec.ts region='StaticClassProviderDifference'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface StaticClassProvider extends StaticClassSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return an instance of a token.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * ```ts
+ * @Injectable(SomeModule, {deps: []})
+ * class MyService {}
+ * ```
+ *
+ * @publicApi
+ */
+export interface ConstructorSansProvider {
+    /**
+     * A list of `token`s to be resolved by the injector.
+     */
+    deps?: any[];
+}
+/**
+ * Configures the `Injector` to return an instance of a token.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ConstructorProvider extends ConstructorSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: Type<any>;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return a value of another `useExisting` token.
+ *
+ * @see `ExistingProvider`
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @publicApi
+ */
+export interface ExistingSansProvider {
+    /**
+     * Existing `token` to return. (Equivalent to `injector.get(useExisting)`)
+     */
+    useExisting: any;
+}
+/**
+ * Configures the `Injector` to return a value of another `useExisting` token.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='ExistingProvider'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ExistingProvider extends ExistingSansProvider {
+    /**
+     * An injection token. Typically an instance of `Type` or `InjectionToken`, but can be `any`.
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Configures the `Injector` to return a value by invoking a `useFactory` function.
+ *
+ * @see `FactoryProvider`
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @publicApi
+ */
+export interface FactorySansProvider {
+    /**
+     * A function to invoke to create a value for this `token`. The function is invoked with
+     * resolved values of `token`s in the `deps` field.
+     */
+    useFactory: Function;
+    /**
+     * A list of `token`s to be resolved by the injector. The list of values is then
+     * used as arguments to the `useFactory` function.
+     */
+    deps?: any[];
+}
+/**
+ * Configures the `Injector` to return a value by invoking a `useFactory` function.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='FactoryProvider'}
+ *
+ * Dependencies can also be marked as optional:
+ *
+ * {@example core/di/ts/provider_spec.ts region='FactoryProviderOptionalDeps'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface FactoryProvider extends FactorySansProvider {
+    /**
+     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * 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 ["Dependency Injection Guide"](guide/dependency-injection-providers).
+ *
+ * @publicApi
+ */
+export declare type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | any[];
+/**
+ * Configures the `Injector` to return an instance of `Type` when `Type' is used as the token.
+ *
+ * Create an instance by invoking the `new` operator and supplying additional arguments.
+ * This form is a short form of `TypeProvider`;
+ *
+ * For more details, see the ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='TypeProvider'}
+ *
+ * @publicApi
+ */
+export interface TypeProvider extends Type<any> {
+}
+/**
+ * Configures the `Injector` to return a value by invoking a `useClass` function.
+ * Base for `ClassProvider` decorator.
+ *
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @publicApi
+ */
+export interface ClassSansProvider {
+    /**
+     * Class to instantiate for the `token`.
+     */
+    useClass: Type<any>;
+}
+/**
+ * Configures the `Injector` to return an instance of `useClass` for a token.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @usageNotes
+ *
+ * {@example core/di/ts/provider_spec.ts region='ClassProvider'}
+ *
+ * Note that following two providers are not equal:
+ *
+ * {@example core/di/ts/provider_spec.ts region='ClassProviderDifference'}
+ *
+ * ### Multi-value example
+ *
+ * {@example core/di/ts/provider_spec.ts region='MultiProviderAspect'}
+ *
+ * @publicApi
+ */
+export interface ClassProvider extends ClassSansProvider {
+    /**
+     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
+     */
+    provide: any;
+    /**
+     * When true, injector returns an array of instances. This is useful to allow multiple
+     * providers spread across many files to provide configuration information to a common token.
+     */
+    multi?: boolean;
+}
+/**
+ * Describes how the `Injector` should be configured.
+ * @see ["Dependency Injection Guide"](guide/dependency-injection).
+ *
+ * @see `StaticProvider`
+ *
+ * @publicApi
+ */
+export declare type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];
+/**
+ * Describes a function that is used to process provider lists (such as provider
+ * overrides).
+ */
+export declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];

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

@@ -0,0 +1,49 @@
+/**
+ * @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 { Type } from "../interface/type";
+/**
+ * An interface that a function passed into {@link forwardRef} has to implement.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref_fn'}
+ * @publicApi
+ */
+export interface ForwardRefFn {
+    (): any;
+}
+/**
+ * Allows to refer to references which are not yet defined.
+ *
+ * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of
+ * 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.
+ *
+ * @usageNotes
+ * ### Example
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}
+ * @publicApi
+ */
+export declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;
+/**
+ * Lazily retrieves the reference value from a forwardRef.
+ *
+ * Acts as the identity function when given a non-forward-ref value.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * {@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}
+ *
+ * @see `forwardRef`
+ * @publicApi
+ */
+export declare function resolveForwardRef<T>(type: T): T;
+/** Checks whether a function is wrapped by a `forwardRef`. */
+export declare function isForwardRef(fn: any): fn is () => any;

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

@@ -0,0 +1,17 @@
+/**
+ * @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 { InjectFlags } from "./interface/injector";
+import { ProviderToken } from "./provider_token";
+/**
+ * Injects `root` tokens in limp mode.
+ *
+ * If no injector exists, we can still inject tree-shakable providers which have `providedIn` set to
+ * `"root"`. This is known as the limp mode injection. In such case the value is stored in the
+ * injectable definition.
+ */
+export declare function injectRootLimpMode<T>(token: ProviderToken<T>, notFoundValue: T | undefined, flags: InjectFlags): T | null;