@tstdl/base 0.86.0 → 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: injectionContext.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>;
 }

package/injector/provider.d.ts

@@ -1,23 +1,23 @@
 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, C extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<C>) => T;
+import type { AfterResolveContext, ResolveContext } from './types.js';
+export type Factory<T, A = any, D extends Record = Record> = (argument: ResolveArgument<T, A>, context: ResolveContext<D>) => T;
 export type ProviderWithArgument<T, A> = {
     defaultArgument?: ResolveArgument<T, A>;
     defaultArgumentProvider?: () => ResolveArgument<T, A>;
 };
-export type ProviderWithInitializer<T, A, C extends Record> = {
-    afterResolve?: (value: T, argument: A, context: C) => void | Promise<void>;
+export type ProviderWithInitializer<T, A, D extends Record> = {
+    afterResolve?: (value: T, argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
 };
-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> & {
+export type Provider<T = any, A = any, D extends Record = Record> = ClassProvider<T, A, D> | ValueProvider<T> | TokenProvider<T, A, D> | FactoryProvider<T, A, D>;
+export type ClassProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
     useClass: Constructor<T>;
 };
 export type ValueProvider<T = any> = {
     useValue: T;
 };
-export type TokenProvider<T = any, A = any, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & ({
+export type TokenProvider<T = any, A = any, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & ({
     useToken: InjectionToken<T, A>;
     useTokenProvider?: undefined;
 } | {
@@ -29,13 +29,13 @@ export type TokenProvider<T = any, A = any, C extends Record = Record> = Provide
      */
     resolveAll?: boolean;
 };
-export type FactoryProvider<T = any, A = unknown, C extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, C> & {
-    useFactory: Factory<T, A, C>;
+export type FactoryProvider<T = any, A = unknown, D extends Record = Record> = ProviderWithArgument<T, A> & ProviderWithInitializer<T, A, D> & {
+    useFactory: Factory<T, A, D>;
 };
-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 classProvider<T, A, D extends Record>(constructor: Constructor<T>, options?: TypedOmit<ClassProvider<T, A, D>, 'useClass'>): ClassProvider<T, A, D>;
 export declare function valueProvider<T>(value: T, options?: TypedOmit<ValueProvider<T>, 'useValue'>): ValueProvider<T>;
-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 tokenProvider<T, A, D extends Record>(token: InjectionToken<T, A>, options?: TypedOmit<TokenProvider<T, A, D>, 'useToken' | 'useTokenProvider'>): TokenProvider<T>;
+export declare function factoryProvider<T, A, D extends Record>(factory: Factory<T, A, D>, options?: TypedOmit<FactoryProvider<T, A, D>, 'useFactory'>): FactoryProvider<T, A, D>;
 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>;

package/injector/resolve.error.d.ts

@@ -1,5 +1,5 @@
 import { CustomError } from '../error/custom.error.js';
-import { ResolveChain } from './resolve-chain.js';
+import type { ResolveChain } from './resolve-chain.js';
 export declare class ResolveError extends CustomError {
     constructor(message: string, chain: ResolveChain, cause?: Error);
 }

package/injector/types.d.ts

@@ -1,5 +1,6 @@
 import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
 import type { Record } from '../types.js';
+import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import type { Injector } from './injector.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
@@ -10,12 +11,18 @@ import type { InjectionToken } from './token.js';
  * singleton: one resolution at injector where token is registered
  */
 export type Lifecycle = 'transient' | 'resolution' | 'injector' | 'singleton';
-export type ResolveContext<C extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
-    context: ResolutionContext<C>;
+export type ResolveContext<D extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationToken: ReadonlyCancellationToken;
+    addDisposeHandler(handler: AsyncDisposeHandler): void;
+};
+export type AfterResolveContext<D extends Record> = {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationToken: ReadonlyCancellationToken;
     addDisposeHandler(handler: AsyncDisposeHandler): void;
 };
 export type Mapper<T = any, U = unknown> = (value: T) => U;
-export type ArgumentProvider<T = unknown, C extends Record = Record> = (context: ResolveContext<C>) => T;
+export type ArgumentProvider<T = unknown, D extends Record = Record> = (context: ResolveContext<D>) => T;
 export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
 export type ResolveOptions = {
     optional?: boolean;
@@ -25,13 +32,13 @@ export type ResolveOptions = {
 /**
  * data to store between different stages like resolve and afterResolve
  */
-export type ResolutionContext<T extends Record> = T;
-export type RegistrationOptions<T, A = unknown, C extends Record = Record> = {
+export type ResolveContextData<T extends Record> = T;
+export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
     lifecycle?: Lifecycle;
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
     defaultArgument?: ResolveArgument<T, A>;
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
-    defaultArgumentProvider?: ArgumentProvider<ResolveArgument<T, A>, C>;
+    defaultArgumentProvider?: ArgumentProvider<ResolveArgument<T, A>, D>;
     /**
      * Value to distinguish scoped and singleton instances based on argument
      * by default it uses strict equality (===) on the original argument,
@@ -43,7 +50,9 @@ export type RegistrationOptions<T, A = unknown, C extends Record = Record> = {
      */
     argumentIdentityProvider?: Mapper<ResolveArgument<T, A>>;
     /** Function which gets called after a resolve */
-    afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: ResolutionContext<C>) => any;
+    afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => any;
     /** Whether multiple values can be resolved or not (used with {@link Injector.resolveAll}). If false, previous registrations are removed */
     multi?: boolean;
+    /** custom metadata */
+    metadata?: Record;
 };

package/logger/console/logger.js

@@ -79,9 +79,9 @@ ConsoleLogger = ConsoleLogger_1 = __decorate([
     provider: {
       useFactory: (argument, context) => {
         if ((0, import_type_guards.isObject)(argument)) {
-          return new ConsoleLogger_1(argument.level ?? context.resolve(import_level.LogLevel), argument.module, argument.prefix);
+          return new ConsoleLogger(argument.level ?? context.resolve(import_level.LogLevel), argument.module, argument.prefix);
         }
-        return new ConsoleLogger_1(context.resolve(import_level.LogLevel), argument, void 0);
+        return new ConsoleLogger(context.resolve(import_level.LogLevel), argument, void 0);
       }
     }
   }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.86.0",
+  "version": "0.86.1",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -20,10 +20,11 @@
     "tsc-alias:watch": "tsc-alias --watch"
   },
   "dependencies": {
+    "disposablestack": "^1.1.1",
     "luxon": "^3.4",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^4.2"
+    "type-fest": "^4.3"
   },
   "devDependencies": {
     "@types/chroma-js": "2.4",
@@ -37,12 +38,12 @@
     "@typescript-eslint/parser": "6.4",
     "concurrently": "8.2",
     "esbuild": "0.19",
-    "eslint": "8.47",
+    "eslint": "8.48",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.28",
     "tsc-alias": "1.8",
-    "typedoc": "0.24",
-    "typescript": "5.1"
+    "typedoc": "0.25",
+    "typescript": "5.2"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.9",

package/polyfills.d.ts

@@ -0,0 +1,159 @@
+import 'disposablestack/auto';
+declare global {
+    interface SymbolConstructor {
+        /**
+         * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
+         */
+        readonly dispose: unique symbol;
+        /**
+         * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
+         */
+        readonly asyncDispose: unique symbol;
+    }
+    interface Disposable {
+        [Symbol.dispose](): void;
+    }
+    interface AsyncDisposable {
+        [Symbol.asyncDispose](): PromiseLike<void>;
+    }
+    interface SuppressedError extends Error {
+        error: any;
+        suppressed: any;
+    }
+    interface SuppressedErrorConstructor extends ErrorConstructor {
+        new (error: any, suppressed: any, message?: string): SuppressedError;
+        (error: any, suppressed: any, message?: string): SuppressedError;
+        readonly prototype: SuppressedError;
+    }
+    var SuppressedError: SuppressedErrorConstructor;
+    interface DisposableStack {
+        /**
+         * Returns a value indicating whether this stack has been disposed.
+         */
+        readonly disposed: boolean;
+        /**
+         * Disposes each resource in the stack in the reverse order that they were added.
+         */
+        dispose(): void;
+        /**
+         * Adds a disposable resource to the stack, returning the resource.
+         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
+         * @returns The provided {@link value}.
+         */
+        use<T extends Disposable | null | undefined>(value: T): T;
+        /**
+         * Adds a value and associated disposal callback as a resource to the stack.
+         * @param value The value to add.
+         * @param onDispose The callback to use in place of a `[Symbol.dispose]()` method. Will be invoked with `value`
+         * as the first parameter.
+         * @returns The provided {@link value}.
+         */
+        adopt<T>(value: T, onDispose: (value: T) => void): T;
+        /**
+         * Adds a callback to be invoked when the stack is disposed.
+         */
+        defer(onDispose: () => void): void;
+        /**
+         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
+         * @example
+         * ```ts
+         * class C {
+         *   #res1: Disposable;
+         *   #res2: Disposable;
+         *   #disposables: DisposableStack;
+         *   constructor() {
+         *     // stack will be disposed when exiting constructor for any reason
+         *     using stack = new DisposableStack();
+         *
+         *     // get first resource
+         *     this.#res1 = stack.use(getResource1());
+         *
+         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
+         *     this.#res2 = stack.use(getResource2());
+         *
+         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
+         *     // when constructor exits
+         *     this.#disposables = stack.move();
+         *   }
+         *
+         *   [Symbol.dispose]() {
+         *     this.#disposables.dispose();
+         *   }
+         * }
+         * ```
+         */
+        move(): DisposableStack;
+        [Symbol.dispose](): void;
+        readonly [Symbol.toStringTag]: string;
+    }
+    interface DisposableStackConstructor {
+        new (): DisposableStack;
+        readonly prototype: DisposableStack;
+    }
+    var DisposableStack: DisposableStackConstructor;
+    interface AsyncDisposableStack {
+        /**
+         * Returns a value indicating whether this stack has been disposed.
+         */
+        readonly disposed: boolean;
+        /**
+         * Disposes each resource in the stack in the reverse order that they were added.
+         */
+        disposeAsync(): Promise<void>;
+        /**
+         * Adds a disposable resource to the stack, returning the resource.
+         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
+         * @returns The provided {@link value}.
+         */
+        use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
+        /**
+         * Adds a value and associated disposal callback as a resource to the stack.
+         * @param value The value to add.
+         * @param onDisposeAsync The callback to use in place of a `[Symbol.asyncDispose]()` method. Will be invoked with `value`
+         * as the first parameter.
+         * @returns The provided {@link value}.
+         */
+        adopt<T>(value: T, onDisposeAsync: (value: T) => PromiseLike<void> | void): T;
+        /**
+         * Adds a callback to be invoked when the stack is disposed.
+         */
+        defer(onDisposeAsync: () => PromiseLike<void> | void): void;
+        /**
+         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
+         * @example
+         * ```ts
+         * class C {
+         *   #res1: Disposable;
+         *   #res2: Disposable;
+         *   #disposables: DisposableStack;
+         *   constructor() {
+         *     // stack will be disposed when exiting constructor for any reason
+         *     using stack = new DisposableStack();
+         *
+         *     // get first resource
+         *     this.#res1 = stack.use(getResource1());
+         *
+         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
+         *     this.#res2 = stack.use(getResource2());
+         *
+         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
+         *     // when constructor exits
+         *     this.#disposables = stack.move();
+         *   }
+         *
+         *   [Symbol.dispose]() {
+         *     this.#disposables.dispose();
+         *   }
+         * }
+         * ```
+         */
+        move(): AsyncDisposableStack;
+        [Symbol.asyncDispose](): Promise<void>;
+        readonly [Symbol.toStringTag]: string;
+    }
+    interface AsyncDisposableStackConstructor {
+        new (): AsyncDisposableStack;
+        readonly prototype: AsyncDisposableStack;
+    }
+    var AsyncDisposableStack: AsyncDisposableStackConstructor;
+}

package/polyfills.js

@@ -0,0 +1,2 @@
+"use strict";
+var import_auto = require("disposablestack/auto");

package/queue/mongo/mongo-job.repository.js

@@ -45,7 +45,6 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var MongoJobRepository_1;
 const indexes = [
   { key: { queue: 1, jobId: 1 }, unique: true },
   { key: { queue: 1, priority: 1, enqueueTimestamp: 1, lastDequeueTimestamp: 1, tries: 1 } },
@@ -53,7 +52,7 @@ const indexes = [
   { key: { queue: 1, batch: 1 } },
   { key: { queue: 1, tries: 1 } }
 ];
-let MongoJobRepository = MongoJobRepository_1 = class MongoJobRepository2 extends import_mongo.MongoEntityRepository {
+let MongoJobRepository = class MongoJobRepository2 extends import_mongo.MongoEntityRepository {
   constructor(collection, logger) {
     super(collection, import_mongo.noopTransformer, { indexes, logger });
   }
@@ -72,9 +71,9 @@ let MongoJobRepository = MongoJobRepository_1 = class MongoJobRepository2 extend
     await bulk.execute(false);
   }
 };
-MongoJobRepository = MongoJobRepository_1 = __decorate([
+MongoJobRepository = __decorate([
   (0, import_injector.Singleton)(),
   __param(0, (0, import_injector.ForwardArg)()),
-  __param(1, (0, import_injector.ResolveArg)(MongoJobRepository_1.name)),
+  __param(1, (0, import_injector.ResolveArg)(MongoJobRepository.name)),
   __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], MongoJobRepository);

package/search-index/elastic/module.js

@@ -43,14 +43,14 @@ function configureElasticsearch(config = {}) {
 import_injector.Injector.registerSingleton(import_elasticsearch.Client, {
   useFactory: (argument, context) => {
     (0, import_type_guards.assertDefined)(argument, "missing elasticsearch client options");
-    context.context.logger = (0, import_inject.inject)(import_logger.Logger, elasticsearchModuleConfig.logPrefix);
+    context.data.logger = (0, import_inject.inject)(import_logger.Logger, elasticsearchModuleConfig.logPrefix);
     const client = new import_elasticsearch.Client(argument);
-    context.addDisposeHandler(async () => client.close().then(() => context.context.logger.info("closed connection")));
+    context.addDisposeHandler(async () => client.close().then(() => context.data.logger.info("closed connection")));
     return client;
   },
-  async afterResolve(client, options, context) {
+  async afterResolve(client, options, { cancellationToken, data: { logger } }) {
     const url = getUrl(options.node ?? options.nodes);
-    await (0, import_core.connect)(`elasticsearch (${url})`, async () => client.ping().then((alive) => (0, import_type_guards.assert)(alive, "failed to connect")), context.logger);
+    await (0, import_core.connect)(`elasticsearch (${url})`, async () => client.ping().then((alive) => (0, import_type_guards.assert)(alive, "failed to connect")), logger, cancellationToken);
   },
   defaultArgumentProvider() {
     return elasticsearchModuleConfig.defaultOptions;

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compileOnSave": false,
   "compilerOptions": {
-    "module": "esnext",
+    "module": "nodenext",
     "moduleResolution": "nodenext",
     "lib": ["esnext", "dom"],
     "target": "es2022",

package/utils/cancellation-token.d.ts

@@ -1,4 +1,4 @@
-import type { Observable, Observer, Subscribable, Subscription } from 'rxjs';
+import type { Observable, Observer, Subscribable, Subscription, Unsubscribable } from 'rxjs';
 export type ConnectConfig = {
     /**
      * Propagate parent set to child.
@@ -31,59 +31,61 @@ export type ConnectConfig = {
      */
     once?: boolean;
 };
-export interface ReadonlyCancellationToken extends PromiseLike<void>, Subscribable<void> {
+export declare abstract class ReadonlyCancellationToken implements PromiseLike<void>, Subscribable<void> {
     /**
      * Returns whether this token set.
      */
-    readonly isSet: boolean;
+    abstract readonly isSet: boolean;
     /**
      * Returns whether this token unset.
      */
-    readonly isUnset: boolean;
+    abstract readonly isUnset: boolean;
     /**
      * Observable which emits the current state and every state change.
      */
-    readonly state$: Observable<boolean>;
+    abstract readonly state$: Observable<boolean>;
     /**
      * Observable which emits when this token is set.
      */
-    readonly set$: Observable<void>;
+    abstract readonly set$: Observable<void>;
     /**
      * Observable which emits when this token is unset.
      */
-    readonly unset$: Observable<void>;
+    abstract readonly unset$: Observable<void>;
     /**
      * Returns a promise which is resolved when this token is set.
      */
-    readonly $set: Promise<void>;
+    abstract readonly $set: Promise<void>;
     /**
      * Returns a promise which is resolved when this token is unset.
      */
-    readonly $unset: Promise<void>;
+    abstract readonly $unset: Promise<void>;
     /**
      * Returns a promise which is resolved when this token changes its state.
      */
-    readonly $state: Promise<boolean>;
+    abstract readonly $state: Promise<boolean>;
     /**
      * Returns an AbortSignal.
      */
-    asAbortSignal(): AbortSignal;
+    abstract asAbortSignal(): AbortSignal;
     /**
      * Create a new token and connect it to this instance.
      * @see {@link connect}
      */
-    createChild(config?: ConnectConfig): CancellationToken;
+    abstract createChild(config?: ConnectConfig): CancellationToken;
     /**
      * Propagate events from this instance to the `child`. Events from the `child` are *not* propagated to this instance.
      * @param child child to connect
      */
-    connect(child: CancellationToken, config?: ConnectConfig): void;
+    abstract connect(child: CancellationToken, config?: ConnectConfig): void;
+    abstract subscribe(observer: Partial<Observer<void>>): Unsubscribable;
+    abstract then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
 }
-export declare class CancellationToken implements ReadonlyCancellationToken {
-    private readonly stateSubject;
+export declare class CancellationToken extends ReadonlyCancellationToken {
+    #private;
     readonly state$: Observable<boolean>;
-    readonly set$: Observable<void>;
-    readonly unset$: Observable<void>;
+    readonly set$: Observable<undefined>;
+    readonly unset$: Observable<undefined>;
     get isSet(): boolean;
     get isUnset(): boolean;
     get $set(): Promise<void>;

package/utils/cancellation-token.js

@@ -18,23 +18,26 @@ var __copyProps = (to, from2, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var cancellation_token_exports = {};
 __export(cancellation_token_exports, {
-  CancellationToken: () => CancellationToken
+  CancellationToken: () => CancellationToken,
+  ReadonlyCancellationToken: () => ReadonlyCancellationToken
 });
 module.exports = __toCommonJS(cancellation_token_exports);
-var import_noop = require("../rxjs/noop.js");
 var import_rxjs = require("rxjs");
+var import_noop = require("../rxjs/noop.js");
 var import_noop2 = require("./noop.js");
 var import_type_guards = require("./type-guards.js");
-class CancellationToken {
-  stateSubject;
-  state$;
-  set$;
-  unset$;
+class ReadonlyCancellationToken {
+}
+class CancellationToken extends ReadonlyCancellationToken {
+  #stateSubject = new import_rxjs.BehaviorSubject(false);
+  state$ = this.#stateSubject.pipe((0, import_rxjs.distinctUntilChanged)());
+  set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
+  unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
   get isSet() {
-    return this.stateSubject.value;
+    return this.#stateSubject.value;
   }
   get isUnset() {
-    return !this.stateSubject.value;
+    return !this.#stateSubject.value;
   }
   get $set() {
     return (0, import_rxjs.firstValueFrom)(this.set$);
@@ -52,10 +55,8 @@ class CancellationToken {
    * @default false
    */
   constructor(initialState = false) {
-    this.stateSubject = new import_rxjs.BehaviorSubject(initialState);
-    this.state$ = this.stateSubject.pipe((0, import_rxjs.distinctUntilChanged)());
-    this.set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
-    this.unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
+    super();
+    this.#stateSubject.next(initialState);
   }
   static from(source, config) {
     const source$ = source instanceof AbortSignal ? (0, import_rxjs.fromEvent)(source, "abort", () => true) : (0, import_rxjs.isObservable)(source) ? source.pipe((0, import_rxjs.map)((state) => (0, import_type_guards.isBoolean)(state) ? state : true)) : (0, import_rxjs.from)(source).pipe((0, import_rxjs.map)(() => true));
@@ -71,7 +72,7 @@ class CancellationToken {
       error: error ? (errorValue) => target.error(errorValue) : import_noop2.noop,
       complete: complete ? () => target.complete() : import_noop2.noop
     });
-    target.stateSubject.subscribe({
+    target.#stateSubject.subscribe({
       error: () => subscription.unsubscribe(),
       complete: () => subscription.unsubscribe()
     });
@@ -103,25 +104,25 @@ class CancellationToken {
    * Set this token.
    */
   set() {
-    this.stateSubject.next(true);
+    this.#stateSubject.next(true);
   }
   /**
    * Unset this token.
    */
   unset() {
-    this.stateSubject.next(false);
+    this.#stateSubject.next(false);
   }
   /**
    * Set the state.
    */
   setState(state) {
-    this.stateSubject.next(state);
+    this.#stateSubject.next(state);
   }
   /**
    * Errors the token.
    */
   error(error) {
-    this.stateSubject.error(error);
+    this.#stateSubject.error(error);
   }
   /**
    * Clean up subscriptions.
@@ -129,7 +130,7 @@ class CancellationToken {
    * Keep in mind that *active* awaits (promise) on this token will throw.
    */
   complete() {
-    this.stateSubject.complete();
+    this.#stateSubject.complete();
   }
   async then(onfulfilled) {
     await this.$set;

package/global-this.d.ts

@@ -1 +0,0 @@
-export declare function ensureGlobalThis(): void;

package/global-this.js

@@ -1,37 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var global_this_exports = {};
-__export(global_this_exports, {
-  ensureGlobalThis: () => ensureGlobalThis
-});
-module.exports = __toCommonJS(global_this_exports);
-function ensureGlobalThis() {
-  if (typeof globalThis === "object") {
-    return;
-  }
-  Object.defineProperty(Object.prototype, "__magic__", {
-    get() {
-      return this;
-    },
-    configurable: true
-    // this makes it possible to `delete` the getter later.
-  });
-  __magic__.globalThis = __magic__;
-  delete Object.prototype["__magic__"];
-}