static-injector 2.1.0 → 2.2.0

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

@@ -8,13 +8,10 @@
 import { Injector } from './injector';
 import { InjectorType } from './interface/defs';
 import { InjectFlags, InjectOptions } from './interface/injector';
-import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
+import { EnvironmentProviders, Provider } from './interface/provider';
+import { SingleProvider } from './provider_collection';
 import { ProviderToken } from './provider_token';
 import { InjectorScope } from './scope';
-/**
- * Internal type for a single provider in a deep provider array.
- */
-type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
 export declare function getNullInjector(): Injector;
 /**
  * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
@@ -56,19 +53,20 @@ export declare abstract class EnvironmentInjector implements Injector {
     /**
      * Runs the given function in the context of this `EnvironmentInjector`.
      *
-     * Within the function's stack frame, `inject` can be used to inject dependencies from this
-     * injector. Note that `inject` is only usable synchronously, and cannot be used in any
-     * asynchronous callbacks or after any `await` points.
+     * Within the function's stack frame, [`inject`](api/core/inject) can be used to inject
+     * dependencies from this injector. Note that `inject` is only usable synchronously, and cannot be
+     * used in any asynchronous callbacks or after any `await` points.
      *
      * @param fn the closure to be run in the context of this injector
      * @returns the return value of the function, if any
+     * @deprecated use the standalone function `runInInjectionContext` instead
      */
     abstract runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
     abstract destroy(): void;
     /**
      * @internal
      */
-    abstract onDestroy(callback: () => void): void;
+    abstract onDestroy(callback: () => void): () => void;
 }
 export declare class R3Injector extends EnvironmentInjector {
     readonly parent: Injector;
@@ -91,7 +89,7 @@ export declare class R3Injector extends EnvironmentInjector {
     get destroyed(): boolean;
     private _destroyed;
     private injectorDefTypes;
-    constructor(providers: Array<Provider>, parent: Injector, source: string | null, scopes: Set<InjectorScope>);
+    constructor(providers: Array<Provider | EnvironmentProviders>, parent: Injector, source: string | null, scopes: Set<InjectorScope>);
     /**
      * Destroy the injector and release references to every instance or provider associated with it.
      *
@@ -99,19 +97,20 @@ export declare class R3Injector extends EnvironmentInjector {
      * hook was found.
      */
     destroy(): void;
-    onDestroy(callback: () => void): void;
+    onDestroy(callback: () => void): () => void;
     runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
     get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags | InjectOptions): T;
     /** @internal */
     resolveInjectorInitializers(): void;
     toString(): string;
-    private assertNotDestroyed;
+    assertNotDestroyed(): void;
     /**
      * Process a `SingleProvider` and add it.
      */
     private processProvider;
     private hydrate;
     private injectableDefInScope;
+    private removeOnDestroy;
 }
 /**
  * Converts a `SingleProvider` into a factory function.
@@ -119,5 +118,3 @@ export declare class R3Injector extends EnvironmentInjector {
  * @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

@@ -12,4 +12,4 @@ export type InjectorScope = 'root' | 'platform' | 'environment';
  * 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<InjectorScope>;
+export declare const INJECTOR_SCOPE: InjectionToken<InjectorScope | null>;

package/import/typings/error_details_base_url.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+/**
+ * Base URL for the error details page.
+ *
+ * Keep this constant in sync across:
+ *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
+ *  - packages/core/src/error_details_base_url.ts
+ */
+export declare const ERROR_DETAILS_PAGE_BASE_URL = "https://angular.io/errors";
+/**
+ * URL for the XSS security documentation.
+ */
+export declare const XSS_SECURITY_URL = "https://g.co/ng/security#xss";

package/import/typings/errors.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @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
+ */
+/**
+ * The list of error codes used in runtime code of the `core` package.
+ * Reserved error code range: 100-999.
+ *
+ * Note: the minus sign denotes the fact that a particular code has a detailed guide on
+ * angular.io. This extra annotation is needed to avoid introducing a separate set to store
+ * error codes which have guides, which might leak into runtime code.
+ *
+ * Full list of available error guides can be found at https://angular.io/errors.
+ *
+ * Error code ranges per package:
+ *  - core (this package): 100-999
+ *  - forms: 1000-1999
+ *  - common: 2000-2999
+ *  - animations: 3000-3999
+ *  - router: 4000-4999
+ *  - platform-browser: 5000-5500
+ */
+export declare const enum RuntimeErrorCode {
+    EXPRESSION_CHANGED_AFTER_CHECKED = -100,
+    RECURSIVE_APPLICATION_REF_TICK = 101,
+    RECURSIVE_APPLICATION_RENDER = 102,
+    CYCLIC_DI_DEPENDENCY = -200,
+    PROVIDER_NOT_FOUND = -201,
+    INVALID_FACTORY_DEPENDENCY = 202,
+    MISSING_INJECTION_CONTEXT = -203,
+    INVALID_INJECTION_TOKEN = 204,
+    INJECTOR_ALREADY_DESTROYED = 205,
+    PROVIDER_IN_WRONG_CONTEXT = 207,
+    MISSING_INJECTION_TOKEN = 208,
+    INVALID_MULTI_PROVIDER = -209,
+    MISSING_DOCUMENT = 210,
+    MULTIPLE_COMPONENTS_MATCH = -300,
+    EXPORT_NOT_FOUND = -301,
+    PIPE_NOT_FOUND = -302,
+    UNKNOWN_BINDING = 303,
+    UNKNOWN_ELEMENT = 304,
+    TEMPLATE_STRUCTURE_ERROR = 305,
+    INVALID_EVENT_BINDING = 306,
+    HOST_DIRECTIVE_UNRESOLVABLE = 307,
+    HOST_DIRECTIVE_NOT_STANDALONE = 308,
+    DUPLICATE_DIRECTITVE = 309,
+    HOST_DIRECTIVE_COMPONENT = 310,
+    HOST_DIRECTIVE_UNDEFINED_BINDING = 311,
+    HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
+    MULTIPLE_MATCHING_PIPES = 313,
+    MULTIPLE_PLATFORMS = 400,
+    PLATFORM_NOT_FOUND = 401,
+    MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
+    BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,
+    PLATFORM_ALREADY_DESTROYED = 404,
+    ASYNC_INITIALIZERS_STILL_RUNNING = 405,
+    APPLICATION_REF_ALREADY_DESTROYED = 406,
+    RENDERER_NOT_FOUND = 407,
+    HYDRATION_NODE_MISMATCH = -500,
+    HYDRATION_MISSING_SIBLINGS = -501,
+    HYDRATION_MISSING_NODE = -502,
+    UNSUPPORTED_PROJECTION_DOM_NODES = -503,
+    INVALID_SKIP_HYDRATION_HOST = -504,
+    MISSING_HYDRATION_ANNOTATIONS = -505,
+    HYDRATION_STABLE_TIMEDOUT = -506,
+    MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,
+    SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,
+    REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,
+    INVALID_I18N_STRUCTURE = 700,
+    MISSING_LOCALE_DATA = 701,
+    IMPORT_PROVIDERS_FROM_STANDALONE = 800,
+    INVALID_DIFFER_INPUT = 900,
+    NO_SUPPORTING_DIFFER_FACTORY = 901,
+    VIEW_ALREADY_ATTACHED = 902,
+    INVALID_INHERITANCE = 903,
+    UNSAFE_VALUE_IN_RESOURCE_URL = 904,
+    UNSAFE_VALUE_IN_SCRIPT = 905,
+    MISSING_GENERATED_DEF = 906,
+    TYPE_IS_NOT_STANDALONE = 907,
+    MISSING_ZONEJS = 908,
+    UNEXPECTED_ZONE_STATE = 909,
+    UNSAFE_IFRAME_ATTRS = -910,
+    VIEW_ALREADY_DESTROYED = 911,
+    COMPONENT_ID_COLLISION = -912,
+    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000
+}
+/**
+ * Class that represents a runtime error.
+ * Formats and outputs the error message in a consistent way.
+ *
+ * Example:
+ * ```
+ *  throw new RuntimeError(
+ *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
+ *    ngDevMode && 'Injector has already been destroyed.');
+ * ```
+ *
+ * Note: the `message` argument contains a descriptive error message as a string in development
+ * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the
+ * `message` argument becomes `false`, thus we account for it in the typings and the runtime
+ * logic.
+ */
+export declare class RuntimeError<T extends number = RuntimeErrorCode> extends Error {
+    code: T;
+    constructor(code: T, message: null | false | string);
+}
+/**
+ * Called to format a runtime error.
+ * See additional info on the `message` argument type in the `RuntimeError` class description.
+ */
+export declare function formatRuntimeError<T extends number = RuntimeErrorCode>(code: T, message: null | false | string): string;

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

@@ -5,6 +5,18 @@
  * 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 a type that a Component or other object is instances of.
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is represented by
+ * the `MyCustomComponent` constructor function.
+ *
+ * @publicApi
+ */
+export declare const Type: FunctionConstructor;
+export declare function isType(v: any): v is Type<any>;
 /**
  * @description
  *
@@ -19,3 +31,36 @@ export interface AbstractType<T> extends Function {
 export interface Type<T> extends Function {
     new (...args: any[]): T;
 }
+export type Mutable<T extends {
+    [x: string]: any;
+}, K extends string> = {
+    [P in K]: T[P];
+};
+/**
+ * Returns a writable type version of type.
+ *
+ * USAGE:
+ * Given:
+ * ```
+ * interface Person {readonly name: string}
+ * ```
+ *
+ * We would like to get a read/write version of `Person`.
+ * ```
+ * const WritablePerson = Writable<Person>;
+ * ```
+ *
+ * The result is that you can do:
+ *
+ * ```
+ * const readonlyPerson: Person = {name: 'Marry'};
+ * readonlyPerson.name = 'John'; // TypeError
+ * (readonlyPerson as WritablePerson).name = 'John'; // OK
+ *
+ * // Error: Correctly detects that `Person` did not have `age` property.
+ * (readonlyPerson as WritablePerson).age = 30;
+ * ```
+ */
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};

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

@@ -1,2 +1,9 @@
+/**
+ * @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 when a token is not found in DI. */
 export declare function throwProviderNotFoundError(token: any, injectorName?: string): never;

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

@@ -6,3 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export declare const NG_FACTORY_DEF: string;
+/**
+ * The `NG_ENV_ID` field on a DI token indicates special processing in the `EnvironmentInjector`:
+ * getting such tokens from the `EnvironmentInjector` will bypass the standard DI resolution
+ * strategy and instead will return implementation produced by the `NG_ENV_ID` factory function.
+ *
+ * This particular retrieval of DI tokens is mostly done to eliminate circular dependencies and
+ * improve tree-shaking.
+ */
+export declare const NG_ENV_ID: string;

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

@@ -1,10 +1,3 @@
-/**
- * @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.

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

@@ -1,10 +1,18 @@
-/**
- * @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[];
+/**
+ * `KeyValueArray` is an array where even positions contain keys and odd positions contain values.
+ *
+ * `KeyValueArray` provides a very efficient way of iterating over its contents. For small
+ * sets (~10) the cost of binary searching an `KeyValueArray` has about the same performance
+ * characteristics that of a `Map` with significantly better memory footprint.
+ *
+ * If used as a `Map` the keys are stored in alphabetical order so that they can be binary searched
+ * for retrieval.
+ *
+ * See: `keyValueArraySet`, `keyValueArrayGet`, `keyValueArrayIndexOf`, `keyValueArrayDelete`.
+ */
+export interface KeyValueArray<VALUE> extends Array<VALUE | string> {
+    __brand__: 'array-map';
+}

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

@@ -23,5 +23,7 @@ export interface TypeDecorator {
      */
     <T extends Type<any>>(type: T): T;
     (target: Object, propertyKey?: string | symbol, parameterIndex?: number): void;
+    (target: unknown, context: unknown): void;
 }
-export declare function makeParamDecorator(name: string, props?: (...args: any[]) => any): any;
+export declare const PARAMETERS = "__parameters__";
+export declare function makeParamDecorator(name: string, props?: (...args: any[]) => any, parentClass?: any): any;

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

@@ -11,4 +11,5 @@
  * allows for identity checks against these values to be consistently used by the framework
  * code.
  */
+export declare const EMPTY_OBJ: {};
 export declare const EMPTY_ARRAY: any[];

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "static-injector",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Angular的静态注入器独立使用版本",
   "keywords": [
     "angular",
     "injector",
     "typescript",
-    "typescript 4.9",
+    "typescript 5.1.6",
     "injectable",
     "static-inject"
   ],
@@ -19,17 +19,17 @@
   },
   "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",
+  "es2022": "import/fesm2022/index.js",
+  "fesm2022": "import/fesm2022/index.js",
+  "esm2022": "import/esm2022/index.js",
+  "module": "import/fesm2022/index.js",
   "typings": "import/typings/index.d.ts",
   "private": false,
   "scripts": {},
   "author": "wszgrcy",
   "license": "MIT",
   "peerDependencies": {
-    "typescript": "^4.9.3"
+    "typescript": "~5.1.6"
   },
   "devDependencies": {},
   "sideEffects": false

package/readme.md

@@ -2,7 +2,10 @@
 
 - 这是 Angualr 依赖注入的独立版本,初始版本逻辑为从 Angular 源码中提取出来,并修复了一些已知 bug
 - 使用方法与 Angular 的依赖注入完全一致
-
+# 来源
+- Angular 16.2.2
+# 兼容
+- ts 5.1.6
 # 使用方法
 
 - 以`Injector.create`创建第一级依赖注入器

package/transform/compiler/src/injectable_compiler_2.d.ts

@@ -11,7 +11,6 @@ import { MaybeForwardRefExpression, R3CompiledExpression, R3Reference } from './
 export interface R3InjectableMetadata {
     name: string;
     type: R3Reference;
-    internalType: o.Expression;
     typeArgumentCount: number;
     providedIn: MaybeForwardRefExpression;
     useClass?: MaybeForwardRefExpression;

package/transform/compiler/src/injectable_compiler_2.js

@@ -41,7 +41,6 @@ function compileInjectable(meta, resolveForwardRefs) {
     const factoryMeta = {
         name: meta.name,
         type: meta.type,
-        internalType: meta.internalType,
         typeArgumentCount: meta.typeArgumentCount,
         deps: [],
         target: r3_factory_1.FactoryTarget.Injectable,
@@ -53,14 +52,19 @@ function compileInjectable(meta, resolveForwardRefs) {
         //
         // A special case exists for useClass: Type where Type is the injectable type itself and no
         // deps are specified, in which case 'useClass' is effectively ignored.
-        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.internalType);
+        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.type.value);
         let deps = undefined;
         if (meta.deps !== undefined) {
             deps = meta.deps;
         }
         if (deps !== undefined) {
             // factory: () => new meta.useClass(...deps)
-            result = (0, r3_factory_1.compileFactoryFunction)(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useClass.expression, delegateDeps: deps, delegateType: r3_factory_1.R3FactoryDelegateType.Class }));
+            result = (0, r3_factory_1.compileFactoryFunction)({
+                ...factoryMeta,
+                delegate: meta.useClass.expression,
+                delegateDeps: deps,
+                delegateType: r3_factory_1.R3FactoryDelegateType.Class,
+            });
         }
         else if (useClassOnSelf) {
             result = (0, r3_factory_1.compileFactoryFunction)(factoryMeta);
@@ -74,7 +78,12 @@ function compileInjectable(meta, resolveForwardRefs) {
     }
     else if (meta.useFactory !== undefined) {
         if (meta.deps !== undefined) {
-            result = (0, r3_factory_1.compileFactoryFunction)(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useFactory, delegateDeps: meta.deps || [], delegateType: r3_factory_1.R3FactoryDelegateType.Function }));
+            result = (0, r3_factory_1.compileFactoryFunction)({
+                ...factoryMeta,
+                delegate: meta.useFactory,
+                delegateDeps: meta.deps || [],
+                delegateType: r3_factory_1.R3FactoryDelegateType.Function,
+            });
         }
         else {
             result = {
@@ -87,21 +96,27 @@ function compileInjectable(meta, resolveForwardRefs) {
         // Note: it's safe to use `meta.useValue` instead of the `USE_VALUE in meta` check used for
         // client code because meta.useValue is an Expression which will be defined even if the actual
         // value is undefined.
-        result = (0, r3_factory_1.compileFactoryFunction)(Object.assign(Object.assign({}, factoryMeta), { expression: meta.useValue.expression }));
+        result = (0, r3_factory_1.compileFactoryFunction)({
+            ...factoryMeta,
+            expression: meta.useValue.expression,
+        });
     }
     else if (meta.useExisting !== undefined) {
         // useExisting is an `inject` call on the existing token.
-        result = (0, r3_factory_1.compileFactoryFunction)(Object.assign(Object.assign({}, factoryMeta), { expression: o
+        result = (0, r3_factory_1.compileFactoryFunction)({
+            ...factoryMeta,
+            expression: o
                 .importExpr(r3_identifiers_1.Identifiers.inject)
-                .callFn([meta.useExisting.expression]) }));
+                .callFn([meta.useExisting.expression]),
+        });
     }
     else {
         result = {
             statements: [],
-            expression: delegateToFactory(meta.type.value, meta.internalType, resolveForwardRefs),
+            expression: delegateToFactory(meta.type.value, meta.type.value, resolveForwardRefs),
         };
     }
-    const token = meta.internalType;
+    const token = meta.type.value;
     const injectableProps = new util_2.DefinitionMap();
     injectableProps.set('token', token);
     injectableProps.set('factory', result.expression);
@@ -125,30 +140,30 @@ function createInjectableType(meta) {
     ]));
 }
 exports.createInjectableType = createInjectableType;
-function delegateToFactory(type, internalType, unwrapForwardRefs) {
-    if (type.node === internalType.node) {
+function delegateToFactory(type, useType, unwrapForwardRefs) {
+    if (type.node === useType.node) {
         // The types are the same, so we can simply delegate directly to the type's factory.
         // ```
         // factory: type.ɵfac
         // ```
-        return internalType.prop('ɵfac');
+        return useType.prop('ɵfac');
     }
     if (!unwrapForwardRefs) {
         // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that
         // accepts a sub-type as an argument.
         // ```
-        // factory: function(t) { return internalType.ɵfac(t); }
+        // factory: function(t) { return useType.ɵfac(t); }
         // ```
-        return createFactoryFunction(internalType);
+        return createFactoryFunction(useType);
     }
-    // The internalType is actually wrapped in a `forwardRef()` so we need to resolve that before
+    // The useType is actually wrapped in a `forwardRef()` so we need to resolve that before
     // calling its factory.
     // ```
     // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); }
     // ```
     const unwrappedType = o
         .importExpr(r3_identifiers_1.Identifiers.resolveForwardRef)
-        .callFn([internalType]);
+        .callFn([useType]);
     return createFactoryFunction(unwrappedType);
 }
 function createFactoryFunction(type) {