@tstdl/base 0.85.26 → 0.86.0-beta10

package/injector/inject.d.ts

@@ -10,6 +10,7 @@ export type InjectArgumentOptions = {
     optional?: boolean;
 };
 export type InjectionContext = {
+    injector: Injector;
     argument: unknown;
     inject<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T;
     injectAll<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: InjectOptions): T[];
@@ -62,7 +63,10 @@ export declare function injectAllAsync<T, A>(token: InjectionToken<T, A>, argume
 export declare function injectArgument<T, R>(_this?: Resolvable<T>, options?: InjectArgumentOptions & {
     optional: R;
 }): T | (R extends true ? undefined : never);
-export declare function getCurrentInjectionContext(): InjectionContext | null;
+export declare function getCurrentInjectionContext(required: true): InjectionContext;
+export declare function getCurrentInjectionContext(required?: boolean): InjectionContext | null;
+export declare function getCurrentInjector(required: true): Injector;
+export declare function getCurrentInjector(required?: boolean): Injector | null;
 export declare function setCurrentInjectionContext(context: InjectionContext | null): InjectionContext | null;
 /**
  * Runs the given function in the context of the given {@link InjectionContext}.
@@ -72,6 +76,7 @@ export declare function setCurrentInjectionContext(context: InjectionContext | n
  * @returns the return value of the function, if any
  */
 export declare function runInInjectionContext<ReturnT>(injectorOrContext: Injector | InjectionContext, fn: () => ReturnT): ReturnT;
+export declare function isInInjectionContext(): boolean;
 /**
  * Asserts that the current stack frame is within an injection context and has access to {@link inject}.
  *

package/injector/inject.js

@@ -20,11 +20,13 @@ var inject_exports = {};
 __export(inject_exports, {
   assertInInjectionContext: () => assertInInjectionContext,
   getCurrentInjectionContext: () => getCurrentInjectionContext,
+  getCurrentInjector: () => getCurrentInjector,
   inject: () => inject,
   injectAll: () => injectAll,
   injectAllAsync: () => injectAllAsync,
   injectArgument: () => injectArgument,
   injectAsync: () => injectAsync,
+  isInInjectionContext: () => isInInjectionContext,
   runInInjectionContext: () => runInInjectionContext,
   setCurrentInjectionContext: () => setCurrentInjectionContext
 });
@@ -56,9 +58,15 @@ function injectArgument(_this, options) {
   }
   return argument;
 }
-function getCurrentInjectionContext() {
+function getCurrentInjectionContext(required = false) {
+  if (required) {
+    assertInInjectionContext(getCurrentInjector);
+  }
   return currentInjectionContext;
 }
+function getCurrentInjector(required = false) {
+  return getCurrentInjectionContext(required)?.injector ?? null;
+}
 function setCurrentInjectionContext(context) {
   const previous = currentInjectionContext;
   currentInjectionContext = context;
@@ -66,6 +74,7 @@ function setCurrentInjectionContext(context) {
 }
 function runInInjectionContext(injectorOrContext, fn) {
   const context = injectorOrContext instanceof import_injector.Injector ? {
+    injector: injectorOrContext,
     argument: void 0,
     inject(token, argument, options) {
       return injectorOrContext.resolve(token, argument, options);
@@ -87,8 +96,11 @@ function runInInjectionContext(injectorOrContext, fn) {
     setCurrentInjectionContext(previousContext);
   }
 }
+function isInInjectionContext() {
+  return (0, import_type_guards.isNotNull)(currentInjectionContext);
+}
 function assertInInjectionContext(debugFn) {
-  if ((0, import_type_guards.isNull)(currentInjectionContext)) {
+  if (!isInInjectionContext()) {
     throw new Error(`${debugFn.name}() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\``);
   }
 }

package/injector/injector.d.ts

@@ -1,31 +1,10 @@
-import { CircularBuffer } from '../data-structures/circular-buffer.js';
-import { MultiKeyMap } from '../data-structures/multi-key-map.js';
-import { DeferredPromise } from '../promise/deferred-promise.js';
-import type { TypedOmit } from '../types.js';
-import { ForwardRef } from '../utils/object/forward-ref.js';
+import type { AsyncDisposable } from '../disposable/disposable.js';
+import { disposeAsync } from '../disposable/disposable.js';
+import type { OneOrMany, Record, TypedOmit } from '../types.js';
 import type { ResolveArgument } from './interfaces.js';
 import { type Provider } from './provider.js';
-import { ResolveChain } from './resolve-chain.js';
 import { type InjectionToken } from './token.js';
 import type { RegistrationOptions, ResolveOptions } from './types.js';
-type InternalResolveContext = {
-    resolves: number;
-    /** Currently resolving tokens (for circular dependency detection) */
-    resolving: Set<InjectionToken>;
-    /** resolutions for resolution scoped dependencies  */
-    resolutionScopedResolutions: MultiKeyMap<[InjectionToken, unknown], Resolution<any, any>>;
-    /** all resolutions in this chain for postprocessing */
-    resolutions: Resolution<any, any>[];
-    forwardRefQueue: CircularBuffer<(() => void | Promise<void>)>;
-    forwardRefs: Set<ForwardRef>;
-    $done: DeferredPromise;
-};
-type Resolution<T, A> = {
-    registration: Registration<T>;
-    value: T;
-    argument: ResolveArgument<T, A>;
-    chain: ResolveChain;
-};
 export type GlobalRegistration<T = any, A = any> = {
     token: InjectionToken<T, A>;
     provider: Provider<T, A>;
@@ -38,7 +17,7 @@ export type GetRegistrationOptions = {
     skipSelf?: boolean;
     onlySelf?: boolean;
 };
-export declare class Injector {
+export declare class Injector implements AsyncDisposable {
     #private;
     readonly name: string;
     constructor(name: string, parent?: Injector | null);
@@ -48,14 +27,16 @@ export declare class Injector {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static register<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
+    static register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): void;
     /**
      * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
      * @param token token to register
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static registerSingleton<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
+    static registerSingleton<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
+    dispose(): Promise<void>;
+    [disposeAsync](): Promise<void>;
     fork(name: string): Injector;
     /**
      * Register a provider for a token
@@ -63,14 +44,14 @@ export declare class Injector {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    register<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: RegistrationOptions<T, A>): void;
+    register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): void;
     /**
      * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
      * @param token token to register
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    registerSingleton<T, A = any>(token: InjectionToken<T, A>, provider: Provider<T, A>, options?: TypedOmit<RegistrationOptions<T, A>, 'lifecycle'>): void;
+    registerSingleton<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: TypedOmit<RegistrationOptions<T, A, C>, 'lifecycle'>): void;
     /**
      * Check if token has a registered provider
      * @param token token check
@@ -96,10 +77,10 @@ export declare class Injector {
     }): Promise<T | undefined>;
     resolveAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): Promise<T>;
     resolveAllAsync<T, A>(token: InjectionToken<T, A>, argument?: ResolveArgument<T, A>, options?: ResolveOptions): Promise<T[]>;
-    _resolve<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T | undefined;
-    _resolveAll<T, A>(token: InjectionToken<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T[];
-    _resolveRegistration<T, A>(registration: Registration<T, A>, argument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T;
-    _resolveProvider<T, A>(registration: Registration<T, A>, resolveArgument: ResolveArgument<T, A>, options: ResolveOptions, context: InternalResolveContext, chain: ResolveChain): T;
+    private _resolve;
+    private _resolveAll;
+    private _resolveRegistration;
+    private _resolveProvider;
     private resolveClassInjection;
     private resolveInjection;
     private resolveInjectionAsync;
@@ -108,4 +89,3 @@ export declare class Injector {
     private getResolveContext;
     private getInjectionContext;
 }
-export {};

package/injector/injector.js

@@ -23,9 +23,12 @@ __export(injector_exports, {
 module.exports = __toCommonJS(injector_exports);
 var import_circular_buffer = require("../data-structures/circular-buffer.js");
 var import_multi_key_map = require("../data-structures/multi-key-map.js");
+var import_async_disposer = require("../disposable/async-disposer.js");
+var import_disposable = require("../disposable/disposable.js");
 var import_deferred_promise = require("../promise/deferred-promise.js");
 var import_registry = require("../reflection/registry.js");
 var import_array = require("../utils/array/array.js");
+var import_factory_map = require("../utils/factory-map.js");
 var import_forward_ref = require("../utils/object/forward-ref.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
@@ -39,6 +42,8 @@ var import_token = require("./token.js");
 class Injector {
   static #globalRegistrations = /* @__PURE__ */ new Map();
   #parent;
+  #children = [];
+  #disposer = new import_async_disposer.AsyncDisposer();
   #registrations = /* @__PURE__ */ new Map();
   #injectorScopedResolutions = new import_multi_key_map.MultiKeyMap();
   name;
@@ -53,13 +58,15 @@ class Injector {
    * @param provider provider used to resolve the token
    * @param options registration options
    */
-  static register(token, provider, options = {}) {
-    const registration = {
-      token,
-      provider,
-      options
-    };
-    addRegistration(Injector.#globalRegistrations, registration);
+  static register(token, providers, options = {}) {
+    for (const provider of (0, import_array.toArray)(providers)) {
+      const registration = {
+        token,
+        provider,
+        options: { multi: (0, import_type_guards.isArray)(providers), ...options }
+      };
+      addRegistration(Injector.#globalRegistrations, registration);
+    }
   }
   /**
    * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
@@ -67,11 +74,20 @@ class Injector {
    * @param provider provider used to resolve the token
    * @param options registration options
    */
-  static registerSingleton(token, provider, options) {
-    Injector.register(token, provider, { ...options, lifecycle: "singleton" });
+  static registerSingleton(token, providers, options) {
+    Injector.register(token, providers, { ...options, lifecycle: "singleton" });
+  }
+  async dispose() {
+    await this.#disposer.dispose();
+  }
+  async [import_disposable.disposeAsync]() {
+    await this.dispose();
   }
   fork(name) {
-    return new Injector(name, this);
+    const child = new Injector(name, this);
+    this.#children.push(child);
+    this.#disposer.add(child);
+    return child;
   }
   /**
    * Register a provider for a token
@@ -79,14 +95,16 @@ class Injector {
    * @param provider provider used to resolve the token
    * @param options registration options
    */
-  register(token, provider, options = {}) {
-    const registration = {
-      token,
-      provider,
-      options,
-      resolutions: /* @__PURE__ */ new Map()
-    };
-    addRegistration(this.#registrations, registration);
+  register(token, providers, options = {}) {
+    for (const provider of (0, import_array.toArray)(providers)) {
+      const registration = {
+        token,
+        provider,
+        options: { multi: (0, import_type_guards.isArray)(providers), ...options },
+        resolutions: /* @__PURE__ */ new Map()
+      };
+      addRegistration(this.#registrations, registration);
+    }
   }
   /**
    * Register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
@@ -94,8 +112,8 @@ class Injector {
    * @param provider provider used to resolve the token
    * @param options registration options
    */
-  registerSingleton(token, provider, options) {
-    this.register(token, provider, { ...options, lifecycle: "singleton" });
+  registerSingleton(token, providers, options) {
+    this.register(token, providers, { ...options, lifecycle: "singleton" });
   }
   /**
    * Check if token has a registered provider
@@ -203,12 +221,13 @@ class Injector {
     checkOverflow(chain, context);
     const injectionContext = this.getInjectionContext(context, argument, chain);
     const previousInjectionContext = (0, import_inject.setCurrentInjectionContext)(injectionContext);
+    const resolutionTag = Symbol();
     try {
       const token = registration.token;
       const resolutionScoped = registration.options.lifecycle == "resolution";
       const injectorScoped = registration.options.lifecycle == "injector";
       const singletonScoped = registration.options.lifecycle == "singleton";
-      const resolveArgument = argument ?? registration.options.defaultArgument ?? registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain));
+      const resolveArgument = argument ?? registration.options.defaultArgument ?? registration.options.defaultArgumentProvider?.(this.getResolveContext(resolutionTag, context, chain));
       const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument);
       if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
         return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
@@ -217,8 +236,8 @@ class Injector {
       } else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
         return registration.resolutions.get(argumentIdentity);
       }
-      const value = this._resolveProvider(registration, resolveArgument, options, context, chain);
-      const resolution = { registration, value, argument, chain };
+      const value = this._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
+      const resolution = { tag: resolutionTag, registration, value, argument: injectionContext.argument, chain };
       context.resolutions.push(resolution);
       if (resolutionScoped) {
         context.resolutionScopedResolutions.setFlat(token, argumentIdentity, resolution);
@@ -234,47 +253,61 @@ class Injector {
       (0, import_inject.setCurrentInjectionContext)(previousInjectionContext);
     }
   }
-  _resolveProvider(registration, resolveArgument, options, context, chain) {
+  _resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain) {
     try {
       setResolving(registration.token, context, chain);
       const provider = registration.provider;
+      let result;
       if ((0, import_provider.isClassProvider)(provider)) {
         const typeMetadata = import_registry.reflectionRegistry.getMetadata(provider.useClass);
         const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        if (provider.useClass.length > 0 && ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(import_symbols.injectMetadataSymbol))) {
+        injectionContext.argument = arg;
+        if (provider.useClass.length > 0 && ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(import_symbols.injectableMetadataSymbol))) {
           throw new import_resolve_error.ResolveError(`${provider.useClass.name} has constructor parameters but is not injectable.`, chain);
         }
-        const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(context, provider.useClass, metadata, arg, chain));
-        return new provider.useClass(...parameters);
+        const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
+        result = { value: new provider.useClass(...parameters) };
       }
       if ((0, import_provider.isValueProvider)(provider)) {
-        return provider.useValue;
+        result = { value: provider.useValue };
       }
       if ((0, import_provider.isTokenProvider)(provider)) {
         const innerToken = provider.useToken ?? provider.useTokenProvider();
         const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
-        return this._resolve(innerToken, arg, options, context, chain.addToken(innerToken));
+        injectionContext.argument = arg;
+        if (provider.resolveAll == true) {
+          return this._resolveAll(innerToken, arg, options, context, chain.addToken(innerToken));
+        }
+        result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(innerToken)) };
       }
       if ((0, import_provider.isFactoryProvider)(provider)) {
         try {
-          return provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
+          const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
+          injectionContext.argument = arg;
+          result = { value: provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain)) };
         } catch (error) {
-          throw new import_resolve_error.ResolveError("Error in factory.", chain, error);
+          throw new import_resolve_error.ResolveError("Error in provider factory.", chain, error);
         }
       }
-      throw new Error("Unsupported provider.");
+      if ((0, import_type_guards.isUndefined)(result)) {
+        throw new Error("Unsupported provider.");
+      }
+      if ((0, import_disposable.isDisposable)(result.value) || (0, import_disposable.isAsyncDisposable)(result.value)) {
+        this.#disposer.add(result.value);
+      }
+      return result.value;
     } finally {
       deleteResolving(registration.token, context);
     }
   }
-  resolveClassInjection(context, constructor, metadata, resolveArgument, chain) {
+  resolveClassInjection(resolutionTag, context, constructor, metadata, resolveArgument, chain) {
     const getChain = (injectToken2) => chain.addParameter(constructor, metadata.index, injectToken2).addToken(injectToken2);
     const injectMetadata = metadata.data.tryGet(import_symbols.injectMetadataSymbol) ?? {};
     const injectToken = injectMetadata.injectToken ?? metadata.type;
     if ((0, import_type_guards.isDefined)(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || (0, import_type_guards.isDefined)(resolveArgument) || (0, import_type_guards.isUndefined)(injectToken))) {
       return injectMetadata.injectArgumentMapper(resolveArgument);
     }
-    const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken)));
+    const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(resolutionTag, context, getChain(injectToken)));
     if ((0, import_type_guards.isDefined)(injectMetadata.forwardRefToken)) {
       const forwardRef = import_forward_ref.ForwardRef.create();
       const forwardRefToken = injectMetadata.forwardRefToken;
@@ -283,7 +316,7 @@ class Injector {
         if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
           throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
         }
-        const resolved2 = this._resolve(forwardToken, parameterResolveArgument, { optional: injectMetadata.optional }, context, getChain(forwardToken));
+        const resolved2 = this[injectMetadata.resolveAll == true ? "_resolveAll" : "_resolve"](forwardToken, parameterResolveArgument, { optional: injectMetadata.optional }, context, getChain(forwardToken));
         import_forward_ref.ForwardRef.setRef(forwardRef, resolved2);
       });
       context.forwardRefs.add(forwardRef);
@@ -326,15 +359,20 @@ class Injector {
     await context.$done;
     return values;
   }
-  getResolveContext(resolveContext, chain) {
+  getResolveContext(resolutionTag, resolveContext, chain) {
     const context = {
       resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
-      resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(token))
+      resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
+      addDisposeHandler: (handler) => this.#disposer.add(handler),
+      get context() {
+        return resolveContext.resolutionContexts.get(resolutionTag);
+      }
     };
     return context;
   }
   getInjectionContext(resolveContext, resolveArgument, chain) {
     const context = {
+      injector: this,
       argument: resolveArgument,
       inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, chain),
       injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, chain),
@@ -370,6 +408,7 @@ function newInternalResolveContext() {
     resolving: /* @__PURE__ */ new Set(),
     resolutionScopedResolutions: new import_multi_key_map.MultiKeyMap(),
     resolutions: [],
+    resolutionContexts: new import_factory_map.FactoryMap(() => ({})),
     forwardRefQueue: new import_circular_buffer.CircularBuffer(),
     forwardRefs: /* @__PURE__ */ new Set(),
     $done: new import_deferred_promise.DeferredPromise()
@@ -380,18 +419,20 @@ function postProcess(context) {
     fn();
   }
   derefForwardRefs(context);
-  for (let i = context.resolutions.length - 1; i >= 0; i--) {
-    const resolution = context.resolutions[i];
+  for (const resolution of context.resolutions) {
     if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
-      const returnValue = resolution.value[import_interfaces.afterResolve](resolution.argument);
+      const resolutionContext = context.resolutionContexts.get(resolution.tag);
+      const returnValue = resolution.value[import_interfaces.afterResolve](resolution.argument, resolutionContext);
       throwOnPromise(returnValue, "[afterResolve]", resolution.chain);
     }
     if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
-      const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument);
+      const resolutionContext = context.resolutionContexts.get(resolution.tag);
+      const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolutionContext);
       throwOnPromise(returnValue, "provider afterResolve handler", resolution.chain);
     }
     if ((0, import_type_guards.isDefined)(resolution.registration.options.afterResolve)) {
-      const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument);
+      const resolutionContext = context.resolutionContexts.get(resolution.tag);
+      const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolutionContext);
       throwOnPromise(returnValue, "registration afterResolve handler", resolution.chain);
     }
   }
@@ -401,16 +442,18 @@ async function postProcessAsync(context) {
     fn();
   }
   derefForwardRefs(context);
-  for (let i = context.resolutions.length - 1; i >= 0; i--) {
-    const resolution = context.resolutions[i];
+  for (const resolution of context.resolutions) {
     if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
-      await resolution.value[import_interfaces.afterResolve](resolution.argument);
+      const resolutionContext = context.resolutionContexts.get(resolution.tag);
+      await resolution.value[import_interfaces.afterResolve](resolution.argument, resolutionContext);
     }
     if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
-      await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument);
+      const resolutionContext = context.resolutionContexts.get(resolution.tag);
+      await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolutionContext);
     }
     if ((0, import_type_guards.isDefined)(resolution.registration.options.afterResolve)) {
-      await resolution.registration.options.afterResolve(resolution.value, resolution.argument);
+      const resolutionContext = context.resolutionContexts.get(resolution.tag);
+      await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolutionContext);
     }
   }
 }
@@ -435,7 +478,7 @@ function throwOnPromise(value, type, chain) {
   }
 }
 function checkOverflow(chain, context) {
-  if (chain.length > 750 || ++context.resolves > 750) {
+  if (chain.length > 100 || ++context.resolves > 7500) {
     throw new import_resolve_error.ResolveError("Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle or forwardRef instead.", chain);
   }
 }

package/injector/interfaces.d.ts

@@ -1,14 +1,16 @@
-import type { Type } from '../types.js';
-import type { InjectionToken } from './token.js';
+import type { Record, Type } from '../types.js';
+import type { ArgumentedInjectionToken, InjectionTokenArgument, ReifyingInjectionToken } from './token.js';
 export declare const resolveArgumentType: unique symbol;
 export declare const afterResolve: unique symbol;
 export type ResolveArgumentType = typeof resolveArgumentType;
-export type ResolveArgument<T, Fallback = undefined> = (T extends Resolvable<infer U> ? U : T extends Type<Resolvable<infer U>> ? U : T extends InjectionToken<infer U, infer A> ? ResolveArgument<U, A> : Fallback) | undefined;
-export interface Resolvable<A = unknown> {
+export type ResolveArgument<T, Fallback = undefined> = undefined | (T extends Resolvable<infer U> ? U : T extends Type<Resolvable<infer U>> ? U : T extends (ArgumentedInjectionToken<any, any> | ReifyingInjectionToken) ? InjectionTokenArgument<T> : Fallback);
+export interface Resolvable<A = unknown, C extends Record = Record> extends Partial<AfterResolve<A, C>> {
     /**
      * type of resolve argument
      * @deprecated only used for type inference
      */
     readonly [resolveArgumentType]: A;
-    [afterResolve]?(argument: A): void | Promise<void>;
+}
+export interface AfterResolve<A = unknown, C extends Record = Record> {
+    [afterResolve](argument: A, context: C): void | Promise<void>;
 }

package/injector/provider.d.ts

@@ -1,36 +1,41 @@
-import type { Constructor, TypedOmit } from '../types.js';
+import type { Constructor, Record, TypedOmit } from '../types.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 import type { ResolveContext } from './types.js';
-export type Factory<T, A = any> = (argument: ResolveArgument<T, A>, context: ResolveContext) => T;
+export type Factory<T, A = any, C extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<C>) => T;
 export type ProviderWithArgument<T, A> = {
     defaultArgument?: ResolveArgument<T, A>;
     defaultArgumentProvider?: () => ResolveArgument<T, A>;
 };
-export type ProviderWithInitializer<T, A> = {
-    afterResolve?: (value: T, argument: A) => void | Promise<void>;
+export type ProviderWithInitializer<T, A, C extends Record> = {
+    afterResolve?: (value: T, argument: A, context: C) => void | Promise<void>;
 };
-export type Provider<T = any, A = any> = ClassProvider<T> | ValueProvider<T> | TokenProvider<T, A> | FactoryProvider<T, A>;
-export type ClassProvider<T = any, A = any> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A> & {
+export type Provider<T = any, A = any, C extends Record = Record> = ClassProvider<T, A, C> | ValueProvider<T> | TokenProvider<T, A, C> | FactoryProvider<T, A, C>;
+export type ClassProvider<T = any, A = any, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & {
     useClass: Constructor<T>;
 };
 export type ValueProvider<T = any> = {
     useValue: T;
 };
-export type TokenProvider<T = any, A = any> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A> & ({
+export type TokenProvider<T = any, A = any, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & ({
     useToken: InjectionToken<T, A>;
     useTokenProvider?: undefined;
 } | {
     useToken?: undefined;
     useTokenProvider: () => InjectionToken<T, A>;
-});
-export type FactoryProvider<T = any, A = unknown> = {
-    useFactory: Factory<T, A>;
+}) & {
+    /**
+     * whether to resolve all providers registered for the token
+     */
+    resolveAll?: boolean;
 };
-export declare function classProvider<T, A>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A>, 'useClass'>): ClassProvider<T, A>;
+export type FactoryProvider<T = any, A = unknown, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & {
+    useFactory: Factory<T, A, C>;
+};
+export declare function classProvider<T, A, C extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, C>, 'useClass'>): ClassProvider<T, A, C>;
 export declare function valueProvider<T>(value: T, options?: TypedOmit<ValueProvider<T>, 'useValue'>): ValueProvider<T>;
-export declare function tokenProvider<T, A>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
-export declare function factoryProvider<T, A>(factory: Factory<T, A>, options?: TypedOmit<FactoryProvider<T, A>, 'useFactory'>): FactoryProvider<T, A>;
+export declare function tokenProvider<T, A, C extends Record>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T, A, C>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
+export declare function factoryProvider<T, A, C extends Record>(factory: Factory<T, A, C>, options?: TypedOmit<FactoryProvider<T, A, C>, 'useFactory'>): FactoryProvider<T, A, C>;
 export declare function isClassProvider<T, A>(value: Provider<T, A>): value is ClassProvider<T, A>;
 export declare function isClassProvider<T, A>(value: unknown): value is ClassProvider<T, A>;
 export declare function isValueProvider<T>(value: Provider<T>): value is ValueProvider<T>;
@@ -41,4 +46,4 @@ export declare function isFactoryProvider<T, A>(value: Provider<T, A>): value is
 export declare function isFactoryProvider<T, A>(value: unknown): value is FactoryProvider<T, A>;
 export declare function isProvider<T, A>(value: Provider<T, A>): value is Provider<T, A>;
 export declare function isProvider<T, A>(value: unknown): value is Provider<T, A>;
-export declare function isProviderWithInitializer<T, A>(value: Provider<T, A>): value is Extract<Provider<T, A>, ProviderWithInitializer<T, A>>;
+export declare function isProviderWithInitializer<T, A, C extends Record>(value: Provider<T, A, C>): value is Extract<Provider<T, A, C>, ProviderWithInitializer<T, A, C>>;

package/injector/token.d.ts

@@ -2,13 +2,20 @@ import type { AbstractConstructor } from '../types.js';
 declare const type: unique symbol;
 declare const argument: unique symbol;
 export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
-    [argument]?: A;
+    [argument]: A;
 };
 export type SimpleInjectionToken<T> = AbstractConstructor<T> | object;
 export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
+export type InjectionTokenArgument<T extends ArgumentedInjectionToken<any, any> | ReifyingInjectionToken> = T[typeof argument];
 export declare class ReifyingInjectionToken<T = any, A = any> {
-    private readonly [type];
-    private readonly [argument];
+    /**
+     * @deprecated for internal typing
+     */
+    readonly [type]: T;
+    /**
+     * @deprecated for internal typing
+     */
+    readonly [argument]: A;
     readonly description: string;
     constructor(description: string);
     toString(): string;

package/injector/token.js

@@ -37,5 +37,5 @@ function injectionToken(description) {
   return new ReifyingInjectionToken(description);
 }
 function getTokenName(token) {
-  return (0, import_type_guards.isFunction)(token) ? token.name : (0, import_type_guards.isString)(token) ? `"${token}"` : String(token);
+  return (0, import_type_guards.isFunction)(token) ? token.name : token instanceof ReifyingInjectionToken ? token.toString() : String(token);
 }

package/injector/type-info.d.ts

@@ -7,6 +7,8 @@ export type InjectMetadata = {
     forwardRefToken?: ForwardRefInjectionToken;
     /** whether injection is optional if token is not registered. Set by optional decorator */
     optional?: boolean;
+    /** whether injection should resolve all providers */
+    resolveAll?: boolean;
     /** mapper to map resolved value */
     mapper?: Mapper;
     /** provider to get resolve argument */