static-injector 2.1.1 → 2.2.1

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

@@ -11,6 +11,7 @@ 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 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;

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

@@ -114,7 +114,8 @@ 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.

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,7 +300,7 @@ 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
  */
@@ -315,8 +315,8 @@ export type Provider = TypeProvider | ValueProvider | ClassProvider | Constructo
  *
  * This wrapper type prevents access to the `Provider`s inside.
  *
- * @see `makeEnvironmentProviders`
- * @see `importProvidersFrom`
+ * @see {@link makeEnvironmentProviders}
+ * @see {@link importProvidersFrom}
  *
  * @publicApi
  */
@@ -359,7 +359,7 @@ export interface ModuleWithProviders<T> {
  * 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 `importProvidersFrom`
+ * @see {@link importProvidersFrom}
  *
  * @publicApi
  * @deprecated replaced by `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/provider_collection.d.ts

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Type } from '../interface/type';
-import { InjectorTypeWithProviders } from './interface/defs';
 import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, ModuleWithProviders, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
 /**
  * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
- * referenced in `@Component in a component injector.
+ * referenced in `@Component` in a component injector.
  */
 export declare function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders;
 /**
@@ -65,16 +64,6 @@ export declare function internalImportProvidersFrom(checkForStandaloneCmp: boole
  * Internal type for a single provider in a deep provider array.
  */
 export type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
-/**
- * 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 declare function walkProviderTree(container: Type<unknown> | InjectorTypeWithProviders<unknown>, providersOut: SingleProvider[], parents: Type<unknown>[], dedup: Set<Type<unknown>>): container is InjectorTypeWithProviders<unknown>;
 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/r3_injector.d.ts

@@ -53,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;
@@ -96,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.

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/errors.d.ts

@@ -14,10 +14,19 @@
  * 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,
@@ -27,6 +36,7 @@ export declare const enum RuntimeErrorCode {
     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,
@@ -40,14 +50,25 @@ export declare const enum RuntimeErrorCode {
     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,
-    ERROR_HANDLER_NOT_FOUND = 402,
+    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,
@@ -61,7 +82,10 @@ export declare const enum RuntimeErrorCode {
     TYPE_IS_NOT_STANDALONE = 907,
     MISSING_ZONEJS = 908,
     UNEXPECTED_ZONE_STATE = 909,
-    UNSAFE_IFRAME_ATTRS = -910
+    UNSAFE_IFRAME_ATTRS = -910,
+    VIEW_ALREADY_DESTROYED = 911,
+    COMPONENT_ID_COLLISION = -912,
+    RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000
 }
 /**
  * Class that represents a runtime error.
@@ -76,7 +100,8 @@ export declare const enum RuntimeErrorCode {
  *
  * 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.
+ * `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;

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/util/decorators.d.ts

@@ -23,6 +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 const PARAMETERS = "__parameters__";
 export declare function makeParamDecorator(name: string, props?: (...args: any[]) => any, parentClass?: any): any;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "static-injector",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "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.0.0"
   },
   "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) {