static-injector 1.0.8

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

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

package/import/typings/di/provider_token.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 { AbstractType, Type } from "../interface/type";
+import { InjectionToken } from "./injection_token";
+/**
+ * @description
+ *
+ * Token that can be used to retrieve an instance from an injector or through a query.
+ *
+ * @publicApi
+ */
+export declare type ProviderToken<T> = Type<T> | AbstractType<T> | InjectionToken<T>;

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

@@ -0,0 +1,92 @@
+/**
+ * @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 { Injector } from './injector';
+import { InjectorType } from './interface/defs';
+import { InjectFlags } from './interface/injector';
+import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, TypeProvider, ValueProvider } from './interface/provider';
+import { ProviderToken } from './provider_token';
+/**
+ * Internal type for a single provider in a deep provider array.
+ */
+declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+/**
+ * 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;
+/**
+ * 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): R3Injector;
+export declare class R3Injector {
+    readonly parent: Injector;
+    /**
+     * Map of tokens to records which contain the instances of those tokens.
+     * - `null` value implies that we don't have the record. Used by tree-shakable injectors
+     * to prevent further searches.
+     */
+    private records;
+    /**
+     * The transitive set of `InjectorType`s which define this injector.
+     */
+    private injectorDefTypes;
+    /**
+     * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
+     */
+    private onDestroy;
+    /**
+     * Flag indicating this injector provides the APP_ROOT_SCOPE token, and thus counts as the
+     * root scope.
+     */
+    private readonly scope;
+    readonly source: string | null;
+    /**
+     * Flag indicating that this injector was previously destroyed.
+     */
+    get destroyed(): boolean;
+    private _destroyed;
+    constructor(def: InjectorType<any>, additionalProviders: StaticProvider[] | null, parent: Injector, source?: string | null);
+    /**
+     * Destroy the injector and release references to every instance or provider associated with it.
+     *
+     * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a
+     * hook was found.
+     */
+    destroy(): void;
+    get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags): T;
+    /** @internal */
+    _resolveInjectorDefTypes(): void;
+    toString(): string;
+    private assertNotDestroyed;
+    /**
+     * Add an `InjectorType` or `InjectorTypeWithProviders` and all of its transitive providers
+     * to this injector.
+     *
+     * 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)
+     */
+    /**
+     * Process a `SingleProvider` and add it.
+     */
+    private processProvider;
+    private hydrate;
+    private injectableDefInScope;
+}
+/**
+ * Converts a `SingleProvider` into a factory function.
+ *
+ * @param provider provider to convert to factory
+ */
+export declare function providerToFactory(provider: SingleProvider, ngModuleType?: InjectorType<any>, providers?: any[]): () => any;
+export declare function isTypeProvider(value: SingleProvider): value is TypeProvider;
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * @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 { InjectionToken } from "./injection_token";
+/**
+ * An internal token whose presence in an injector indicates that the injector should treat itself
+ * as a root scoped injector when processing requests for unknown tokens which may indicate
+ * they are provided in the root scope.
+ */
+export declare const INJECTOR_SCOPE: InjectionToken<"root" | "platform">;

package/import/typings/index.d.ts

@@ -0,0 +1,11 @@
+export * from './decorator/injectable';
+export * from './di/metadata';
+export * from './di/r3_injector';
+export * from './di/interface/defs';
+export * from './di/injector_compatibility';
+export * from './di/injection_token';
+export * from './di/null_injector';
+export * from './di/injector';
+export * from './di/interface/injector';
+export * from './di/scope';
+export * from './render3/instructions/di';

package/import/typings/interface/lifecycle_hooks.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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
+ */
+/**
+ * A lifecycle hook that is called when a directive, pipe, or service is destroyed.
+ * Use for any custom cleanup that needs to occur when the
+ * instance is destroyed.
+ * @see [Lifecycle hooks guide](guide/lifecycle-hooks)
+ *
+ * @usageNotes
+ * The following snippet shows how a component can implement this interface
+ * to define its own custom clean-up method.
+ *
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='OnDestroy'}
+ *
+ * @publicApi
+ */
+export interface OnDestroy {
+    /**
+     * A callback method that performs custom clean-up, invoked immediately
+     * before a directive, pipe, or service instance is destroyed.
+     */
+    ngOnDestroy(): void;
+}

package/import/typings/interface/type.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+/**
+ * @description
+ *
+ * Represents an abstract class `T`, if applied to a concrete class it would stop being
+ * instantiable.
+ *
+ * @publicApi
+ */
+export interface AbstractType<T> extends Function {
+    prototype: T;
+}
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}

package/import/typings/render3/definition_factory.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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';
+/**
+ * Definition of what a factory function should look like.
+ */
+export declare type FactoryFn<T> = {
+    /**
+     * Subclasses without an explicit constructor call through to the factory of their base
+     * definition, providing it with their own constructor to instantiate.
+     */
+    <U extends T>(t?: Type<U>): U;
+    /**
+     * If no constructor to instantiate is provided, an instance of type T itself is created.
+     */
+    (t?: undefined): T;
+};
+export declare function getFactoryDef<T>(type: any, throwNotFound: true): FactoryFn<T>;
+export declare function getFactoryDef<T>(type: any): FactoryFn<T> | null;

package/import/typings/render3/error_code.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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
+ */
+export declare const enum RuntimeErrorCode {
+    EXPRESSION_CHANGED_AFTER_CHECKED = "100",
+    CYCLIC_DI_DEPENDENCY = "200",
+    PROVIDER_NOT_FOUND = "201",
+    MULTIPLE_COMPONENTS_MATCH = "300",
+    EXPORT_NOT_FOUND = "301",
+    PIPE_NOT_FOUND = "302",
+    UNKNOWN_BINDING = "303",
+    UNKNOWN_ELEMENT = "304",
+    TEMPLATE_STRUCTURE_ERROR = "305"
+}
+export declare class RuntimeError extends Error {
+    code: RuntimeErrorCode;
+    constructor(code: RuntimeErrorCode, message: string);
+}
+/** Called to format a runtime error */
+export declare function formatRuntimeError(code: RuntimeErrorCode, message: string): string;

package/import/typings/render3/errors_di.d.ts

@@ -0,0 +1,2 @@
+/** Throws an error when a token is not found in DI. */
+export declare function throwProviderNotFoundError(token: any, injectorName?: string): never;

package/import/typings/render3/fields.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export declare const NG_FACTORY_DEF: string;

package/import/typings/render3/instructions/di.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+/**
+ * Throws an error indicating that a factory function could not be generated by the compiler for a
+ * particular class.
+ *
+ * This instruction allows the actual error message to be optimized away when ngDevMode is turned
+ * off, saving bytes of generated code while still providing a good experience in dev mode.
+ *
+ * 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 ɵɵinvalidFactory(): never;

package/import/typings/render3/util/stringify_utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+/**
+ * Used for stringify render output in Ivy.
+ * Important! This function is very performance-sensitive and we should
+ * be extra careful not to introduce megamorphic reads in it.
+ * Check `core/test/render3/perf/render_stringify` for benchmarks and alternate implementations.
+ */
+export declare function renderStringify(value: any): string;
+/**
+ * Used to stringify a value so that it can be displayed in an error message.
+ * Important! This function contains a megamorphic read and should only be
+ * used for error messages.
+ */
+export declare function stringifyForError(value: any): string;

package/import/typings/util/array_utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+export declare function deepForEach<T>(input: (T | any[])[], fn: (value: T) => void): void;
+export declare function newArray<T = any>(size: number): T[];
+export declare function newArray<T>(size: number, value: T): T[];

package/import/typings/util/closure.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
+ */
+/**
+ * Convince closure compiler that the wrapped function has no side-effects.
+ *
+ * Closure compiler always assumes that `toString` has no side-effects. We use this quirk to
+ * allow us to execute a function but have closure compiler mark the call as no-side-effects.
+ * It is important that the return value for the `noSideEffects` function be assigned
+ * to something which is retained otherwise the call to `noSideEffects` will be removed by closure
+ * compiler.
+ */
+export declare function noSideEffects<T>(fn: () => T): T;

package/import/typings/util/decorators.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 implemented by all Angular type decorators, which allows them to be used as
+ * decorators as well as Angular syntax.
+ *
+ * ```
+ * @ng.Component({...})
+ * class MyClass {...}
+ * ```
+ *
+ * @publicApi
+ */
+export interface TypeDecorator {
+    /**
+     * Invoke as decorator.
+     */
+    <T extends Type<any>>(type: T): T;
+    (target: Object, propertyKey?: string | symbol, parameterIndex?: number): void;
+}
+export declare function makeParamDecorator(name: string, props?: (...args: any[]) => any): any;

package/import/typings/util/empty.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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
+ */
+/**
+ * This file contains reuseable "empty" symbols that can be used as default return values
+ * in different parts of the rendering code. Because the same symbols are returned, this
+ * allows for identity checks against these values to be consistently used by the framework
+ * code.
+ */
+export declare const EMPTY_ARRAY: any[];

package/import/typings/util/property.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export declare function getClosureSafeProperty<T>(objWithPropertyToExtract: T): string;

package/import/typings/util/stringify.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export declare function stringify(token: any): string;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "static-injector",
+  "version": "1.0.8",
+  "description": "Angular的静态注入器独立使用版本",
+  "keywords": [
+    "angular",
+    "injector",
+    "typescript",
+    "injectable"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wszgrcy/static-injector.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wszgrcy/static-injector/issues"
+  },
+  "homepage": "https://github.com/wszgrcy/static-injector#readme",
+  "main": "import/commonjs/index.js",
+  "es2015": "import/fesm2015/index.js",
+  "fesm2015": "import/fesm2015/index.js",
+  "esm2015": "import/esm2015/index.js",
+  "module": "import/fesm2015/index.js",
+  "typings": "import/typings/index.d.ts",
+  "private": false,
+  "scripts": {},
+  "author": "wszgrcy",
+  "license": "MIT",
+  "peerDependencies": {
+    "typescript": "^4.0.0"
+  },
+  "devDependencies": {},
+  "sideEffects": false
+}