@tstdl/base 0.86.0 → 0.87.0

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 = require("../cancellation/index.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.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.CancellationSignal, { useValue: this.#disposeToken.signal });
+    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);
+      cancellationSignal: this.#disposeToken,
+      addDisposeHandler: this.#addDisposeHandler,
+      get data() {
+        return resolveContext.resolutionContextData.get(resolutionTag);
+      }
+    };
+    return context;
+  }
+  getAfterResolveContext(resolutionTag, resolveContext) {
+    const context = {
+      cancellationSignal: 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,3 +1,4 @@
+import type { CancellationSignal } from '../cancellation/index.js';
 import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
 import type { Record } from '../types.js';
 import type { Injector } from './injector.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 cancellationSignal: CancellationSignal;
+    addDisposeHandler(handler: AsyncDisposeHandler): void;
+};
+export type AfterResolveContext<D extends Record> = {
+    readonly data: ResolveContextData<D>;
+    readonly cancellationSignal: CancellationSignal;
     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/lock/mongo/lock.js

@@ -21,11 +21,11 @@ __export(lock_exports, {
   MongoLock: () => MongoLock
 });
 module.exports = __toCommonJS(lock_exports);
+var import_cancellation = require("../../cancellation/index.js");
 var import_decorators = require("../../injector/decorators.js");
 var import_lock = require("../../lock/index.js");
 var import_logger = require("../../logger/index.js");
 var import_alphabet = require("../../utils/alphabet.js");
-var import_cancellation_token = require("../../utils/cancellation-token.js");
 var import_date_time = require("../../utils/date-time.js");
 var import_random = require("../../utils/random.js");
 var import_timer = require("../../utils/timer.js");
@@ -78,7 +78,7 @@ let MongoLock = class MongoLock2 extends import_lock.Lock {
       return false;
     }
     let expiration = result;
-    const releaseToken = new import_cancellation_token.CancellationToken();
+    const releaseToken = new import_cancellation.CancellationToken();
     const controller = {
       get lost() {
         return (0, import_date_time.currentTimestamp)() >= expiration.valueOf();

package/lock/web/web-lock.js

@@ -21,9 +21,9 @@ __export(web_lock_exports, {
   WebLock: () => WebLock
 });
 module.exports = __toCommonJS(web_lock_exports);
+var import_cancellation = require("../../cancellation/index.js");
 var import_injector = require("../../injector/index.js");
 var import_deferred_promise = require("../../promise/deferred-promise.js");
-var import_cancellation_token = require("../../utils/cancellation-token.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_rxjs = require("rxjs");
 var import_lock = require("../lock.js");
@@ -55,7 +55,7 @@ let WebLock = class WebLock2 extends import_lock.Lock {
         releasePromise.resolve();
       }
     };
-    const timeoutToken = (0, import_type_guards.isDefined)(timeout) && timeout > 0 ? import_cancellation_token.CancellationToken.from((0, import_rxjs.timer)(timeout).pipe((0, import_rxjs.map)(() => true))) : void 0;
+    const timeoutToken = (0, import_type_guards.isDefined)(timeout) && timeout > 0 ? import_cancellation.CancellationToken.from((0, import_rxjs.timer)(timeout).pipe((0, import_rxjs.map)(() => true))) : void 0;
     void navigator.locks.request(this.resource, {
       signal: (0, import_type_guards.isDefined)(timeoutToken) ? timeoutToken.asAbortSignal() : void 0,
       ifAvailable: (0, import_type_guards.isDefined)(timeout) && timeout <= 0

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/message-bus/message-bus-base.d.ts

@@ -1,7 +1,7 @@
-import type { Logger } from '../logger/index.js';
 import type { Observable } from 'rxjs';
+import type { Logger } from '../logger/index.js';
+import { CancellationToken } from '../cancellation/token.js';
 import { disposeAsync } from '../disposable/disposable.js';
-import { CancellationToken } from '../utils/cancellation-token.js';
 import { MessageBus } from './message-bus.js';
 export declare abstract class MessageBusBase<T> extends MessageBus<T> {
     private readonly logger;

package/message-bus/message-bus-base.js

@@ -22,8 +22,8 @@ __export(message_bus_base_exports, {
 });
 module.exports = __toCommonJS(message_bus_base_exports);
 var import_rxjs = require("rxjs");
+var import_token = require("../cancellation/token.js");
 var import_disposable = require("../disposable/disposable.js");
-var import_cancellation_token = require("../utils/cancellation-token.js");
 var import_message_bus = require("./message-bus.js");
 class MessageBusBase extends import_message_bus.MessageBus {
   logger;
@@ -35,7 +35,7 @@ class MessageBusBase extends import_message_bus.MessageBus {
     super();
     this.logger = logger;
     this.publishSubject = new import_rxjs.Subject();
-    this.disposeToken = new import_cancellation_token.CancellationToken();
+    this.disposeToken = new import_token.CancellationToken();
     this.messages$ = (0, import_rxjs.defer)(() => this._messages$).pipe((0, import_rxjs.takeUntil)(this.disposeToken.set$), (0, import_rxjs.share)());
     this.allMessages$ = (0, import_rxjs.merge)(this.messages$, this.publishSubject);
   }

package/migration/migrator.js

@@ -21,11 +21,11 @@ __export(migrator_exports, {
   Migrator: () => Migrator
 });
 module.exports = __toCommonJS(migrator_exports);
+var import_cancellation = require("../cancellation/index.js");
 var import_injector = require("../injector/index.js");
 var import_lock = require("../lock/index.js");
 var import_logger = require("../logger/index.js");
 var import_array = require("../utils/array/array.js");
-var import_cancellation_token = require("../utils/cancellation-token.js");
 var import_comparison = require("../utils/comparison.js");
 var import_math = require("../utils/math.js");
 var import_timer = require("../utils/timer.js");
@@ -68,7 +68,7 @@ let Migrator = class Migrator2 {
     const { result } = await lock.use(3e4, true, async () => {
       const results = [];
       while (true) {
-        const restartToken = new import_cancellation_token.CancellationToken();
+        const restartToken = new import_cancellation.CancellationToken();
         const control = {
           restart: () => restartToken.set()
         };

package/module/module-base.d.ts

@@ -1,6 +1,6 @@
+import type { CancellationSignal } from '../cancellation/index.js';
+import { CancellationToken } from '../cancellation/index.js';
 import type { StringMap } from '../types.js';
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
-import { CancellationToken } from '../utils/cancellation-token.js';
 import type { Module, ModuleMetric } from './module.js';
 import { ModuleState } from './module.js';
 export declare abstract class ModuleBase implements Module {
@@ -14,5 +14,5 @@ export declare abstract class ModuleBase implements Module {
     constructor(name: string);
     run(): Promise<void>;
     stop(): Promise<void>;
-    protected abstract _run(cancellationToken: ReadonlyCancellationToken): Promise<void>;
+    protected abstract _run(cancellationSignal: CancellationSignal): Promise<void>;
 }

package/module/module-base.js

@@ -21,7 +21,7 @@ __export(module_base_exports, {
   ModuleBase: () => ModuleBase
 });
 module.exports = __toCommonJS(module_base_exports);
-var import_cancellation_token = require("../utils/cancellation-token.js");
+var import_cancellation = require("../cancellation/index.js");
 var import_module = require("./module.js");
 class ModuleBase {
   runPromise;
@@ -38,7 +38,7 @@ class ModuleBase {
     this.name = name;
     this.runPromise = Promise.resolve();
     this._state = import_module.ModuleState.Stopped;
-    this.cancellationToken = new import_cancellation_token.CancellationToken();
+    this.cancellationToken = new import_cancellation.CancellationToken();
   }
   async run() {
     if (this._state != import_module.ModuleState.Stopped) {

package/module/module-metric-reporter.d.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
+import type { CancellationSignal } from '../cancellation/index.js';
 import type { MetricAggregation, MetricAggregationOptions } from '../utils/moving-metric.js';
 import { MovingMetric } from '../utils/moving-metric.js';
 import type { ModuleMetric } from './module.js';
@@ -24,6 +24,6 @@ export declare class ModuleMetricReporter {
         metric: ModuleMetric;
         reports: MetricReport<MetricAggregation>[];
     }[]): void;
-    run(cancellationToken: ReadonlyCancellationToken): Promise<void>;
+    run(cancellationSignal: CancellationSignal): Promise<void>;
     private updateNameLengths;
 }

package/module/module-metric-reporter.js

@@ -51,9 +51,9 @@ class ModuleMetricReporter {
     this.metricGroups.push({ groupName, registrations });
     this.updateNameLengths();
   }
-  async run(cancellationToken) {
+  async run(cancellationSignal) {
     let counter = 0;
-    while (cancellationToken.isUnset) {
+    while (cancellationSignal.isUnset) {
       for (const { registrations } of this.metricGroups) {
         for (const { metric, moving } of registrations) {
           moving.add(metric.getValue());
@@ -71,7 +71,7 @@ class ModuleMetricReporter {
           }
         }
       }
-      await (0, import_timing.cancelableTimeout)(this.sampleInterval, cancellationToken);
+      await (0, import_timing.cancelableTimeout)(this.sampleInterval, cancellationSignal);
     }
   }
   updateNameLengths() {

package/module/modules/function.module.d.ts

@@ -1,10 +1,10 @@
-import type { ReadonlyCancellationToken } from '../../utils/cancellation-token.js';
-import type { Module } from '../module.js';
+import type { CancellationSignal } from '../../cancellation/index.js';
 import { ModuleBase } from '../module-base.js';
-export type FunctionModuleFunction = (cancellationToken: ReadonlyCancellationToken) => void | Promise<void>;
+import type { Module } from '../module.js';
+export type FunctionModuleFunction = (cancellationToken: CancellationSignal) => void | Promise<void>;
 export declare class FunctionModule extends ModuleBase implements Module {
     private readonly fn;
     readonly metrics: {};
     constructor(fn: FunctionModuleFunction, name?: string);
-    protected _run(cancellationToken: ReadonlyCancellationToken): Promise<void>;
+    protected _run(cancellationSignal: CancellationSignal): Promise<void>;
 }

package/module/modules/function.module.js

@@ -29,7 +29,7 @@ class FunctionModule extends import_module_base.ModuleBase {
     super(name);
     this.fn = fn;
   }
-  async _run(cancellationToken) {
-    return this.fn(cancellationToken);
+  async _run(cancellationSignal) {
+    return this.fn(cancellationSignal);
   }
 }

package/module/modules/web-server.module.d.ts

@@ -1,6 +1,6 @@
+import type { CancellationSignal } from '../../cancellation/index.js';
 import type { Resolvable } from '../../injector/interfaces.js';
 import { resolveArgumentType } from '../../injector/interfaces.js';
-import type { ReadonlyCancellationToken } from '../../utils/cancellation-token.js';
 import { ModuleBase } from '../module-base.js';
 import type { Module } from '../module.js';
 import { ModuleMetricType } from '../module.js';
@@ -23,6 +23,6 @@ export declare class WebServerModule extends ModuleBase implements Module, Resol
     readonly [resolveArgumentType]: WebServerModuleConfiguration;
     constructor();
     initialize(): void;
-    protected _run(cancellationToken: ReadonlyCancellationToken): Promise<void>;
+    protected _run(cancellationSignal: CancellationSignal): Promise<void>;
 }
 export declare function configureWebServerModule(config?: Partial<WebServerModuleConfiguration>): void;

package/module/modules/web-server.module.js

@@ -72,10 +72,10 @@ let WebServerModule = class WebServerModule2 extends import_module_base.ModuleBa
       this.apiGateway.registerApi((0, import_server.getApiControllerDefinition)(controller), controller);
     }
   }
-  async _run(cancellationToken) {
+  async _run(cancellationSignal) {
     this.initialize();
     await this.httpServer.listen(this.config.port);
-    const closePromise = cancellationToken.$set.then(async () => {
+    const closePromise = cancellationSignal.$set.then(async () => {
       await this.httpServer[import_disposable.disposeAsync]();
     });
     for await (const context of this.httpServer) {