@tstdl/base 0.86.0-beta9 → 0.86.1

package/application/application.js

@@ -137,7 +137,6 @@ let Application = class Application2 {
       this.#logger.info("Shutting down");
       await this.stopModules(modules);
       await this.#injector.dispose();
-      await (0, import_core.disposeInstances)();
       this.#logger.info("Bye");
     }
     this.#shutdownPromise.resolve();

package/browser/browser-context-controller.d.ts

@@ -5,7 +5,7 @@ import type { Resolvable } from '../injector/interfaces.js';
 import { resolveArgumentType } from '../injector/interfaces.js';
 import type { Logger } from '../logger/logger.js';
 import type { Record } from '../types.js';
-import type { Opaque } from 'type-fest';
+import type { Tagged } from 'type-fest';
 import type { NewBrowserContextOptions } from './browser-controller.js';
 import type { PageControllerOptions } from './page-controller.js';
 import { PageController } from './page-controller.js';
@@ -16,7 +16,7 @@ export type NewPageOptions = {
     extraHttpHeaders?: Record<string, string>;
     controllerOptions?: PageControllerOptions;
 };
-export type BrowserContextState = Opaque<Record<string | number, unknown>, 'BrowserContextState'>;
+export type BrowserContextState = Tagged<Record<string | number, unknown>, 'BrowserContextState'>;
 export type BrowserContextControllerArgument = NewBrowserContextOptions;
 export declare class BrowserContextController implements AsyncDisposable, Resolvable<BrowserContextControllerArgument> {
     /** @deprecated should be avoided */

package/browser/browser-context-controller.js

@@ -43,8 +43,7 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-var BrowserContextController_1;
-let BrowserContextController = BrowserContextController_1 = class BrowserContextController2 {
+let BrowserContextController = class BrowserContextController2 {
   /** @deprecated should be avoided */
   context;
   options;
@@ -95,15 +94,15 @@ let BrowserContextController = BrowserContextController_1 = class BrowserContext
     (0, import_utils.attachLogger)(this.context, logger);
   }
 };
-BrowserContextController = BrowserContextController_1 = __decorate([
+BrowserContextController = __decorate([
   (0, import_decorators.Injectable)({
     provider: {
       useFactory: (_, context) => {
-        context.context.browserController = context.resolve(import_browser_controller.BrowserController);
-        return new BrowserContextController_1(null);
+        context.data.browserController = context.resolve(import_browser_controller.BrowserController);
+        return new BrowserContextController(null);
       },
-      async afterResolve(value, argument, context) {
-        const { context: browserContext, controllerOptions } = await context.browserController.newRawContext(argument);
+      async afterResolve(value, argument, { data: { browserController } }) {
+        const { context: browserContext, controllerOptions } = await browserController.newRawContext(argument);
         value.context = browserContext;
         value.options = controllerOptions;
       }

package/browser/browser-controller.js

@@ -44,8 +44,7 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-var BrowserController_1;
-let BrowserController = BrowserController_1 = class BrowserController2 {
+let BrowserController = class BrowserController2 {
   /** @deprecated should be avoided */
   browser;
   options;
@@ -103,15 +102,15 @@ let BrowserController = BrowserController_1 = class BrowserController2 {
     });
   }
 };
-BrowserController = BrowserController_1 = __decorate([
+BrowserController = __decorate([
   (0, import_decorators.Injectable)({
     provider: {
       useFactory: (_argument, context) => {
-        context.context.browserService = (0, import_inject.inject)(import_browser_service.BrowserService);
-        return new BrowserController_1(null);
+        context.data.browserService = (0, import_inject.inject)(import_browser_service.BrowserService);
+        return new BrowserController(null);
       },
-      async afterResolve(value, argument, context) {
-        const { browser, controllerOptions } = await context.browserService.newRawBrowser(argument);
+      async afterResolve(value, argument, { data: { browserService } }) {
+        const { browser, controllerOptions } = await browserService.newRawBrowser(argument);
         value.browser = browser;
         value.options = controllerOptions;
       }

package/core.d.ts

@@ -1,16 +1,14 @@
-import { AsyncDisposer } from './disposable/async-disposer.js';
 import { Injector } from './injector/injector.js';
 import type { InjectionToken } from './injector/token.js';
 import type { LoggerArgument } from './logger/index.js';
 import { LogLevel, Logger } from './logger/index.js';
+import type { ReadonlyCancellationToken } from './utils/cancellation-token.js';
 export declare const CORE_LOGGER: InjectionToken<Logger, never>;
 export declare const rootInjector: Injector;
-export declare const disposer: AsyncDisposer;
 export declare function isDevMode(): boolean;
 export declare function isProdMode(): boolean;
 export declare function enableProdMode(): void;
-export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, maxTries?: number): Promise<void>;
-export declare function disposeInstances(): Promise<void>;
+export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, cancellationToken: ReadonlyCancellationToken, maxTries?: number): Promise<void>;
 export type CoreConfiguration = {
     production?: boolean;
     logger?: InjectionToken<Logger, LoggerArgument>;

package/core.js

@@ -21,15 +21,12 @@ __export(core_exports, {
   CORE_LOGGER: () => CORE_LOGGER,
   configureTstdl: () => configureTstdl,
   connect: () => connect,
-  disposeInstances: () => disposeInstances,
-  disposer: () => disposer,
   enableProdMode: () => enableProdMode,
   isDevMode: () => isDevMode,
   isProdMode: () => isProdMode,
   rootInjector: () => rootInjector
 });
 module.exports = __toCommonJS(core_exports);
-var import_async_disposer = require("./disposable/async-disposer.js");
 var import_injector = require("./injector/injector.js");
 var import_token = require("./injector/token.js");
 var import_logger = require("./logger/console/logger.js");
@@ -39,7 +36,6 @@ var import_timing = require("./utils/timing.js");
 var import_type_guards = require("./utils/type-guards.js");
 const CORE_LOGGER = (0, import_token.injectionToken)("core logger");
 const rootInjector = new import_injector.Injector("RootInjector");
-const disposer = new import_async_disposer.AsyncDisposer();
 let _isDevMode = true;
 function isDevMode() {
   return _isDevMode;
@@ -50,10 +46,10 @@ function isProdMode() {
 function enableProdMode() {
   _isDevMode = false;
 }
-async function connect(name, connectFunction, logger, maxTries = 5) {
+async function connect(name, connectFunction, logger, cancellationToken, maxTries = 5) {
   let triesLeft = maxTries;
   let success = false;
-  while (!success && !disposer.disposing && triesLeft-- > 0) {
+  while (!success && cancellationToken.isUnset && triesLeft-- > 0) {
     try {
       logger.verbose(`connecting to ${name}...`);
       await connectFunction();
@@ -69,9 +65,6 @@ async function connect(name, connectFunction, logger, maxTries = 5) {
     }
   }
 }
-async function disposeInstances() {
-  await disposer.dispose();
-}
 let coreLogPrefix;
 function configureTstdl(config = {}) {
   if (config.production == true) {

package/database/mongo/module.js

@@ -45,12 +45,12 @@ import_injector.Injector.registerSingleton(import_classes.MongoClient, {
     const client = new import_classes.MongoClient(url, options);
     client.on("fullsetup", () => logger.verbose("connection setup")).on("reconnect", () => logger.warn("reconnected")).on("timeout", () => logger.warn("connection timed out")).on("close", () => logger.verbose("connection closed"));
     context.addDisposeHandler(async () => client.close());
-    context.context.logger = logger;
-    context.context.url = url;
+    context.data.logger = logger;
+    context.data.url = url;
     return client;
   },
-  async afterResolve(client, _argument, context) {
-    await (0, import_core.connect)(`mongo at ${context.url}`, async () => client.connect(), context.logger);
+  async afterResolve(client, _argument, { cancellationToken, data: { url, logger } }) {
+    await (0, import_core.connect)(`mongo at ${url}`, async () => client.connect(), logger, cancellationToken);
   }
 }, {
   defaultArgumentProvider: () => mongoModuleConfig.defaultConnection,
@@ -71,17 +71,17 @@ import_injector.Injector.registerSingleton(import_classes.Collection, {
   useFactory: (config, context) => {
     (0, import_type_guards.assertDefined)(config, "mongo repository config resolve argument missing");
     const database = context.resolve(import_classes.Database, config);
-    context.context.database = database;
+    context.data.database = database;
     return database.collection(config.collection);
   },
-  async afterResolve(_, config, context) {
-    const existingCollections = await context.database.collections();
+  async afterResolve(_, config, { data: { database } }) {
+    const existingCollections = await database.collections();
     for (const collection of existingCollections) {
       if (collection.collectionName == config.collection) {
         return;
       }
     }
-    await context.database.createCollection(config.collection);
+    await database.createCollection(config.collection);
   }
 }, {
   argumentIdentityProvider: JSON.stringify

package/disposable/async-disposer.d.ts

@@ -1,7 +1,6 @@
 import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import { CancellationToken } from '../utils/cancellation-token.js';
 import type { AsyncDisposable, Disposable } from './disposable.js';
-import { disposeAsync } from './disposable.js';
 declare const deferrerToken: unique symbol;
 export type AsyncDisposeTaskFunction = () => any;
 export type AsyncDisposeHandler = AsyncDisposeTaskFunction | Disposable | AsyncDisposable;
@@ -12,16 +11,17 @@ export type Deferrer = {
     [deferrerToken]: CancellationToken;
     yield(): void;
 };
-export declare class AsyncDisposer implements AsyncDisposable {
-    private readonly deferrers;
-    private readonly tasks;
-    readonly _disposingToken: CancellationToken;
-    readonly _disposedToken: CancellationToken;
+export declare class AsyncDisposer implements AsyncDisposable, AsyncDisposableStack {
+    #private;
     get disposingToken(): ReadonlyCancellationToken;
     get disposedToken(): ReadonlyCancellationToken;
     get disposing(): boolean;
     get disposed(): boolean;
+    readonly [Symbol.toStringTag] = "AsyncDisposable";
     constructor();
+    use<T extends globalThis.AsyncDisposable | globalThis.Disposable | null | undefined>(value: T): T;
+    adopt<T>(value: T, onDisposeAsync: (value: T) => void | PromiseLike<void>): T;
+    move(): AsyncDisposableStack;
     getDeferrer(): Deferrer;
     defer<T>(func: () => Promise<T>): Promise<T>;
     /**
@@ -29,7 +29,8 @@ export declare class AsyncDisposer implements AsyncDisposable {
      * @param fnOrDisposable
      */
     add(fnOrDisposable: AsyncDisposeHandler): void;
+    disposeAsync(): Promise<void>;
     dispose(): Promise<void>;
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export {};

package/disposable/async-disposer.js

@@ -27,37 +27,59 @@ var import_cancellation_token = require("../utils/cancellation-token.js");
 var import_disposable = require("./disposable.js");
 const deferrerToken = Symbol("DeferrerToken");
 class AsyncDisposer {
-  deferrers;
-  tasks;
-  _disposingToken;
-  _disposedToken;
+  #disposingToken;
+  #disposedToken;
+  #deferrers;
+  #tasks;
   get disposingToken() {
-    return this._disposingToken;
+    return this.#disposingToken;
   }
   get disposedToken() {
-    return this._disposedToken;
+    return this.#disposedToken;
   }
   get disposing() {
-    return this._disposingToken.isSet;
+    return this.#disposingToken.isSet;
   }
   get disposed() {
-    return this._disposedToken.isSet;
+    return this.#disposedToken.isSet;
   }
+  [Symbol.toStringTag] = "AsyncDisposable";
   constructor() {
-    this.deferrers = /* @__PURE__ */ new Set();
-    this.tasks = [];
-    this._disposingToken = new import_cancellation_token.CancellationToken();
-    this._disposedToken = new import_cancellation_token.CancellationToken();
+    this.#deferrers = /* @__PURE__ */ new Set();
+    this.#tasks = [];
+    this.#disposingToken = new import_cancellation_token.CancellationToken();
+    this.#disposedToken = new import_cancellation_token.CancellationToken();
+  }
+  use(value) {
+    if ((0, import_type_guards.isNullOrUndefined)(value)) {
+      return value;
+    }
+    this.add(value);
+    return value;
+  }
+  adopt(value, onDisposeAsync) {
+    this.add(async () => onDisposeAsync(value));
+    return value;
+  }
+  move() {
+    const disposer = new AsyncDisposer();
+    disposer.#tasks = this.#tasks;
+    disposer.#deferrers = this.#deferrers;
+    this.#tasks = [];
+    this.#deferrers = /* @__PURE__ */ new Set();
+    this.#disposingToken.set();
+    this.#disposedToken.set();
+    return disposer;
   }
   getDeferrer() {
     const deferrer = {
       [deferrerToken]: new import_cancellation_token.CancellationToken(),
       yield: () => {
         deferrer[deferrerToken].set();
-        this.deferrers.delete(deferrer);
+        this.#deferrers.delete(deferrer);
       }
     };
-    this.deferrers.add(deferrer);
+    this.#deferrers.add(deferrer);
     return deferrer;
   }
   async defer(func) {
@@ -75,24 +97,27 @@ class AsyncDisposer {
    */
   add(fnOrDisposable) {
     const fn = (0, import_disposable.isAsyncDisposable)(fnOrDisposable) ? async () => fnOrDisposable[import_disposable.disposeAsync]() : (0, import_disposable.isDisposable)(fnOrDisposable) ? () => fnOrDisposable[import_disposable.dispose]() : fnOrDisposable;
-    this.tasks.push({ taskFunction: fn });
+    this.#tasks.push({ taskFunction: fn });
+  }
+  async disposeAsync() {
+    await this.dispose();
   }
   async dispose() {
     if (this.disposing) {
-      return this._disposedToken.$set;
+      return this.#disposedToken.$set;
     }
-    this._disposingToken.set();
+    this.#disposingToken.set();
     const errors = [];
-    for (const deferrer of this.deferrers) {
+    for (const deferrer of this.#deferrers) {
       try {
         await deferrer[deferrerToken];
       } catch (error2) {
         errors.push(error2);
       }
     }
-    for (let i = this.tasks.length - 1; i >= 0; i--) {
+    for (let i = this.#tasks.length - 1; i >= 0; i--) {
       try {
-        const task = this.tasks[i];
+        const task = this.#tasks[i];
         await task.taskFunction();
       } catch (error2) {
         errors.push(error2);
@@ -100,12 +125,13 @@ class AsyncDisposer {
     }
     const error = errors.length == 1 ? errors[0] : errors.length > 1 ? new import_multi_error.MultiError(errors, "dispose errors") : void 0;
     if ((0, import_type_guards.isDefined)(error)) {
-      this._disposedToken.error(error);
+      this.#disposedToken.error(error);
       throw error;
     }
-    this._disposedToken.set();
+    this.#disposedToken.set();
+    return void 0;
   }
-  async [import_disposable.disposeAsync]() {
+  async [Symbol.asyncDispose]() {
     return this.dispose();
   }
 }

package/disposable/disposable.d.ts

@@ -1,10 +1,11 @@
-export declare const dispose: unique symbol;
-export declare const disposeAsync: unique symbol;
+export declare const dispose: typeof Symbol.dispose;
+export declare const disposeAsync: typeof Symbol.asyncDispose;
 export interface Disposable {
-    [dispose](): void;
+    [Symbol.dispose](): void;
 }
 export interface AsyncDisposable {
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): PromiseLike<void>;
 }
 export declare function isDisposable(object: any): object is Disposable;
 export declare function isAsyncDisposable(object: any): object is AsyncDisposable;
+export declare function isSyncOrAsyncDisposable(object: any): object is Disposable | AsyncDisposable;

package/disposable/disposable.js

@@ -21,15 +21,19 @@ __export(disposable_exports, {
   dispose: () => dispose,
   disposeAsync: () => disposeAsync,
   isAsyncDisposable: () => isAsyncDisposable,
-  isDisposable: () => isDisposable
+  isDisposable: () => isDisposable,
+  isSyncOrAsyncDisposable: () => isSyncOrAsyncDisposable
 });
 module.exports = __toCommonJS(disposable_exports);
 var import_type_guards = require("../utils/type-guards.js");
-const dispose = Symbol("dispose");
-const disposeAsync = Symbol("disposeAsync");
+const dispose = Symbol.dispose;
+const disposeAsync = Symbol.asyncDispose;
 function isDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[dispose]);
+  return (0, import_type_guards.isFunction)(object?.[Symbol.dispose]);
 }
 function isAsyncDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[disposeAsync]);
+  return (0, import_type_guards.isFunction)(object?.[Symbol.asyncDispose]);
+}
+function isSyncOrAsyncDisposable(object) {
+  return (0, import_type_guards.isFunction)(object?.[Symbol.dispose] ?? object?.[Symbol.asyncDispose]);
 }

package/injector/injector.d.ts

@@ -1,5 +1,4 @@
 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';
@@ -17,9 +16,11 @@ export type GetRegistrationOptions = {
     skipSelf?: boolean;
     onlySelf?: boolean;
 };
+export type AddDisposeHandler = (handler: Disposable | AsyncDisposable | (() => any)) => void;
 export declare class Injector implements AsyncDisposable {
     #private;
     readonly name: string;
+    get disposed(): boolean;
     constructor(name: string, parent?: Injector | null);
     /**
      * Globally register a provider for a token
@@ -36,7 +37,7 @@ export declare class Injector implements AsyncDisposable {
      */
     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>;
+    [Symbol.asyncDispose](): Promise<void>;
     fork(name: string): Injector;
     /**
      * Register a provider for a token
@@ -87,5 +88,7 @@ export declare class Injector implements AsyncDisposable {
     private resolveInjectionAll;
     private resolveInjectionAllAsync;
     private getResolveContext;
+    private getAfterResolveContext;
     private getInjectionContext;
+    private assertNotDisposed;
 }

package/injector/injector.js

@@ -23,11 +23,11 @@ __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_cancellation_token = require("../utils/cancellation-token.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");
@@ -43,14 +43,29 @@ class Injector {
   static #globalRegistrations = /* @__PURE__ */ new Map();
   #parent;
   #children = [];
-  #disposer = new import_async_disposer.AsyncDisposer();
+  #disposeToken = new import_cancellation_token.CancellationToken();
+  #disposableStack = new AsyncDisposableStack();
   #registrations = /* @__PURE__ */ new Map();
   #injectorScopedResolutions = new import_multi_key_map.MultiKeyMap();
+  #addDisposeHandler;
   name;
+  get disposed() {
+    return this.#disposableStack.disposed;
+  }
   constructor(name, parent = null) {
     this.name = name;
     this.#parent = parent;
     this.register(Injector, { useValue: this });
+    this.register(import_cancellation_token.CancellationToken, { useValue: this.#disposeToken });
+    this.#addDisposeHandler = (handler) => {
+      if ((0, import_disposable.isSyncOrAsyncDisposable)(handler)) {
+        this.#disposableStack.use(handler);
+      } else {
+        this.#disposableStack.defer(handler);
+      }
+    };
+    this.#disposableStack.defer(() => this.#registrations.clear());
+    this.#disposableStack.defer(() => this.#injectorScopedResolutions.clear());
   }
   /**
    * Globally register a provider for a token
@@ -78,15 +93,16 @@ class Injector {
     Injector.register(token, providers, { ...options, lifecycle: "singleton" });
   }
   async dispose() {
-    await this.#disposer.dispose();
+    this.#disposeToken.set();
+    await this.#disposableStack.disposeAsync();
   }
-  async [import_disposable.disposeAsync]() {
+  async [Symbol.asyncDispose]() {
     await this.dispose();
   }
   fork(name) {
     const child = new Injector(name, this);
     this.#children.push(child);
-    this.#disposer.add(child);
+    this.#disposableStack.use(child);
     return child;
   }
   /**
@@ -96,6 +112,7 @@ class Injector {
    * @param options registration options
    */
   register(token, providers, options = {}) {
+    this.assertNotDisposed();
     for (const provider of (0, import_array.toArray)(providers)) {
       const registration = {
         token,
@@ -184,6 +201,7 @@ class Injector {
     return values;
   }
   _resolve(token, argument, options, context, chain) {
+    this.assertNotDisposed();
     if ((0, import_type_guards.isUndefined)(token)) {
       throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
     }
@@ -201,6 +219,7 @@ class Injector {
     return this._resolveRegistration(singleRegistration, argument, options, context, chain);
   }
   _resolveAll(token, argument, options, context, chain) {
+    this.assertNotDisposed();
     if ((0, import_type_guards.isUndefined)(token)) {
       throw new import_resolve_error.ResolveError("Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.", chain);
     }
@@ -237,7 +256,14 @@ class Injector {
         return registration.resolutions.get(argumentIdentity);
       }
       const value = this._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
-      const resolution = { tag: resolutionTag, registration, value, argument, chain };
+      const resolution = {
+        tag: resolutionTag,
+        registration,
+        value,
+        argument: injectionContext.argument,
+        afterResolveContext: this.getAfterResolveContext(resolutionTag, context),
+        chain
+      };
       context.resolutions.push(resolution);
       if (resolutionScoped) {
         context.resolutionScopedResolutions.setFlat(token, argumentIdentity, resolution);
@@ -293,7 +319,7 @@ class Injector {
         throw new Error("Unsupported provider.");
       }
       if ((0, import_disposable.isDisposable)(result.value) || (0, import_disposable.isAsyncDisposable)(result.value)) {
-        this.#disposer.add(result.value);
+        this.#disposableStack.use(result.value);
       }
       return result.value;
     } finally {
@@ -363,9 +389,20 @@ class Injector {
     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)),
-      addDisposeHandler: (handler) => this.#disposer.add(handler),
-      get context() {
-        return resolveContext.resolutionContexts.get(resolutionTag);
+      cancellationToken: this.#disposeToken,
+      addDisposeHandler: this.#addDisposeHandler,
+      get data() {
+        return resolveContext.resolutionContextData.get(resolutionTag);
+      }
+    };
+    return context;
+  }
+  getAfterResolveContext(resolutionTag, resolveContext) {
+    const context = {
+      cancellationToken: this.#disposeToken,
+      addDisposeHandler: this.#addDisposeHandler,
+      get data() {
+        return resolveContext.resolutionContextData.get(resolutionTag);
       }
     };
     return context;
@@ -381,6 +418,11 @@ class Injector {
     };
     return context;
   }
+  assertNotDisposed() {
+    if (this.disposed) {
+      throw new Error("Injector is disposed.");
+    }
+  }
 }
 function addRegistration(registrations, registration) {
   if ((0, import_provider.isClassProvider)(registration.provider)) {
@@ -408,7 +450,7 @@ function newInternalResolveContext() {
     resolving: /* @__PURE__ */ new Set(),
     resolutionScopedResolutions: new import_multi_key_map.MultiKeyMap(),
     resolutions: [],
-    resolutionContexts: new import_factory_map.FactoryMap(() => ({})),
+    resolutionContextData: new import_factory_map.FactoryMap(() => ({})),
     forwardRefQueue: new import_circular_buffer.CircularBuffer(),
     forwardRefs: /* @__PURE__ */ new Set(),
     $done: new import_deferred_promise.DeferredPromise()
@@ -421,18 +463,15 @@ function postProcess(context) {
   derefForwardRefs(context);
   for (const resolution of context.resolutions) {
     if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
-      const resolutionContext = context.resolutionContexts.get(resolution.tag);
-      const returnValue = resolution.value[import_interfaces.afterResolve](resolution.argument, resolutionContext);
+      const returnValue = resolution.value[import_interfaces.afterResolve](resolution.argument, resolution.afterResolveContext);
       throwOnPromise(returnValue, "[afterResolve]", resolution.chain);
     }
     if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
-      const resolutionContext = context.resolutionContexts.get(resolution.tag);
-      const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolutionContext);
+      const returnValue = resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
       throwOnPromise(returnValue, "provider afterResolve handler", resolution.chain);
     }
     if ((0, import_type_guards.isDefined)(resolution.registration.options.afterResolve)) {
-      const resolutionContext = context.resolutionContexts.get(resolution.tag);
-      const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolutionContext);
+      const returnValue = resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
       throwOnPromise(returnValue, "registration afterResolve handler", resolution.chain);
     }
   }
@@ -444,16 +483,13 @@ async function postProcessAsync(context) {
   derefForwardRefs(context);
   for (const resolution of context.resolutions) {
     if ((0, import_type_guards.isFunction)(resolution.value?.[import_interfaces.afterResolve])) {
-      const resolutionContext = context.resolutionContexts.get(resolution.tag);
-      await resolution.value[import_interfaces.afterResolve](resolution.argument, resolutionContext);
+      await resolution.value[import_interfaces.afterResolve](resolution.argument, resolution.afterResolveContext);
     }
     if ((0, import_provider.isProviderWithInitializer)(resolution.registration.provider)) {
-      const resolutionContext = context.resolutionContexts.get(resolution.tag);
-      await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolutionContext);
+      await resolution.registration.provider.afterResolve?.(resolution.value, resolution.argument, resolution.afterResolveContext);
     }
     if ((0, import_type_guards.isDefined)(resolution.registration.options.afterResolve)) {
-      const resolutionContext = context.resolutionContexts.get(resolution.tag);
-      await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolutionContext);
+      await resolution.registration.options.afterResolve(resolution.value, resolution.argument, resolution.afterResolveContext);
     }
   }
 }

package/injector/interfaces.d.ts

@@ -1,16 +1,17 @@
 import type { Record, Type } from '../types.js';
 import type { ArgumentedInjectionToken, InjectionTokenArgument, ReifyingInjectionToken } from './token.js';
+import type { AfterResolveContext } from './types.js';
 export declare const resolveArgumentType: unique symbol;
 export declare const afterResolve: unique symbol;
 export type ResolveArgumentType = typeof resolveArgumentType;
 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>> {
+export interface Resolvable<A = unknown, D extends Record = Record> extends Partial<AfterResolve<A, D>> {
     /**
      * type of resolve argument
      * @deprecated only used for type inference
      */
     readonly [resolveArgumentType]: A;
 }
-export interface AfterResolve<A = unknown, C extends Record = Record> {
-    [afterResolve](argument: A, context: C): void | Promise<void>;
+export interface AfterResolve<A = unknown, D extends Record = Record> {
+    [afterResolve](argument: A, context: AfterResolveContext<D>): void | Promise<void>;
 }