@tstdl/base 0.86.1 → 0.87.1

package/application/application.d.ts

@@ -1,10 +1,10 @@
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { Resolvable } from '../injector/interfaces.js';
 import { resolveArgumentType } from '../injector/interfaces.js';
 import type { LoggerArgument } from '../logger/index.js';
 import type { Module } from '../module/module.js';
 import type { FunctionModuleFunction } from '../module/modules/function.module.js';
 import type { OneOrMany, Type } from '../types.js';
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 export type BootstrapFn = () => void | Promise<void>;
 export type RunOptions = {
     bootstrap?: BootstrapFn;
@@ -14,8 +14,8 @@ export declare class Application implements Resolvable<LoggerArgument> {
     static _instance: Application | undefined;
     private static get instance();
     readonly [resolveArgumentType]: string;
-    get shutdownToken(): ReadonlyCancellationToken;
-    static get shutdownToken(): ReadonlyCancellationToken;
+    get shutdownSignal(): CancellationSignal;
+    static get shutdownSignal(): CancellationSignal;
     static registerModule(moduleType: Type<Module>): void;
     static registerModuleFunction(fn: FunctionModuleFunction): void;
     static run(...functionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;

package/application/application.js

@@ -53,8 +53,8 @@ let Application = class Application2 {
   static _instance;
   static get instance() {
     if ((0, import_type_guards.isUndefined)(this._instance)) {
-      this._instance = import_core.rootInjector.resolve(Application_1, "App");
-      this._instance.#shutdownToken = import_process_shutdown.shutdownToken;
+      this._instance = (0, import_core.getGlobalInjector)().resolve(Application_1, "App");
+      this._instance.#shutdownToken = (0, import_process_shutdown.getShutdownToken)();
     }
     return this._instance;
   }
@@ -63,12 +63,12 @@ let Application = class Application2 {
   #logger = this.#injector.resolve(import_logger.Logger, this.#name);
   #moduleTypesAndInstances = /* @__PURE__ */ new Set();
   #shutdownPromise = new import_deferred_promise.DeferredPromise();
-  #shutdownToken = import_process_shutdown.shutdownToken.createChild();
-  get shutdownToken() {
-    return this.#shutdownToken.asReadonly();
+  #shutdownToken = (0, import_process_shutdown.getShutdownSignal)().createChild();
+  get shutdownSignal() {
+    return this.#shutdownToken.signal;
   }
-  static get shutdownToken() {
-    return Application_1.instance.shutdownToken;
+  static get shutdownSignal() {
+    return Application_1.instance.shutdownSignal;
   }
   static registerModule(moduleType) {
     Application_1.instance.registerModule(moduleType);
@@ -105,7 +105,7 @@ let Application = class Application2 {
     await this.#shutdownPromise;
   }
   requestShutdown() {
-    if (this.shutdownToken.isSet) {
+    if (this.shutdownSignal.isSet) {
       return;
     }
     this.#shutdownToken.set();
@@ -128,7 +128,7 @@ let Application = class Application2 {
     try {
       await Promise.race([
         this.runModules(modules),
-        this.shutdownToken
+        this.shutdownSignal
       ]);
     } catch (error) {
       this.#logger.error(error, { includeRest: true, includeStack: true });

package/authentication/client/authentication.service.js

@@ -22,6 +22,7 @@ __export(authentication_service_exports, {
 });
 module.exports = __toCommonJS(authentication_service_exports);
 var import_rxjs = require("rxjs");
+var import_token = require("../../cancellation/token.js");
 var import_disposable = require("../../disposable/index.js");
 var import_bad_request_error = require("../../error/bad-request.error.js");
 var import_forbidden_error = require("../../error/forbidden.error.js");
@@ -34,7 +35,6 @@ var import_lock = require("../../lock/index.js");
 var import_logger = require("../../logger/index.js");
 var import_message_bus = require("../../message-bus/index.js");
 var import_api = require("../../signals/api.js");
-var import_cancellation_token = require("../../utils/cancellation-token.js");
 var import_date_time = require("../../utils/date-time.js");
 var import_timing = require("../../utils/timing.js");
 var import_type_guards = require("../../utils/type-guards.js");
@@ -124,9 +124,9 @@ let AuthenticationService = class AuthenticationService2 {
     if ((0, import_type_guards.isUndefined)(this.authenticationData)) {
       this.authenticationData = initialAuthenticationData;
     }
-    this.disposeToken = new import_cancellation_token.CancellationToken();
+    this.disposeToken = new import_token.CancellationToken();
     this.errorSubject = new import_rxjs.Subject();
-    this.forceRefreshToken = new import_cancellation_token.CancellationToken();
+    this.forceRefreshToken = new import_token.CancellationToken();
     this.error$ = this.errorSubject.asObservable();
     this.loggedOut$ = loggedOutBus.allMessages$;
   }

package/cancellation/index.d.ts

@@ -0,0 +1 @@
+export * from './token.js';

package/cancellation/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cancellation_exports = {};
+module.exports = __toCommonJS(cancellation_exports);
+__reExport(cancellation_exports, require("./token.js"), module.exports);

package/{utils/cancellation-token.d.ts → cancellation/token.d.ts}

@@ -1,4 +1,5 @@
-import type { Observable, Observer, Subscribable, Subscription, Unsubscribable } from 'rxjs';
+import type { Observable, Observer, Subscribable, Unsubscribable } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
 export type ConnectConfig = {
     /**
      * Propagate parent set to child.
@@ -31,66 +32,63 @@ export type ConnectConfig = {
      */
     once?: boolean;
 };
-export declare abstract class ReadonlyCancellationToken implements PromiseLike<void>, Subscribable<void> {
-    /**
-     * Returns whether this token set.
-     */
-    abstract readonly isSet: boolean;
-    /**
-     * Returns whether this token unset.
-     */
-    abstract readonly isUnset: boolean;
+export declare class CancellationSignal implements PromiseLike<void>, Subscribable<void> {
+    #private;
     /**
      * Observable which emits the current state and every state change.
      */
-    abstract readonly state$: Observable<boolean>;
+    readonly state$: Observable<boolean>;
     /**
      * Observable which emits when this token is set.
      */
-    abstract readonly set$: Observable<void>;
+    readonly set$: Observable<undefined>;
     /**
      * Observable which emits when this token is unset.
      */
-    abstract readonly unset$: Observable<void>;
+    readonly unset$: Observable<undefined>;
+    /**
+     * Returns a promise which is resolved when this token changes its state.
+     */
+    get $state(): Promise<boolean>;
     /**
      * Returns a promise which is resolved when this token is set.
      */
-    abstract readonly $set: Promise<void>;
+    get $set(): Promise<void>;
     /**
      * Returns a promise which is resolved when this token is unset.
      */
-    abstract readonly $unset: Promise<void>;
+    get $unset(): Promise<void>;
+    get state(): boolean;
     /**
-     * Returns a promise which is resolved when this token changes its state.
+     * Whether this token is set.
      */
-    abstract readonly $state: Promise<boolean>;
+    get isSet(): boolean;
+    /**
+     * Whether this token is unset.
+     */
+    get isUnset(): boolean;
+    constructor(stateSubject: BehaviorSubject<boolean>);
     /**
      * Returns an AbortSignal.
      */
-    abstract asAbortSignal(): AbortSignal;
+    asAbortSignal(): AbortSignal;
     /**
      * Create a new token and connect it to this instance.
      * @see {@link connect}
      */
-    abstract createChild(config?: ConnectConfig): CancellationToken;
+    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
+     * Propagate events from this instance to `target`. Events from the `target` are *not* propagated to this instance.
+     * @param target receiver to connect
      */
-    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>;
+    connect(target: CancellationToken, config?: ConnectConfig): void;
+    then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
+    subscribe(observer: Partial<Observer<void>>): Unsubscribable;
 }
-export declare class CancellationToken extends ReadonlyCancellationToken {
+export declare class CancellationToken extends CancellationSignal {
     #private;
-    readonly state$: Observable<boolean>;
-    readonly set$: Observable<undefined>;
-    readonly unset$: Observable<undefined>;
-    get isSet(): boolean;
-    get isUnset(): boolean;
-    get $set(): Promise<void>;
-    get $unset(): Promise<void>;
-    get $state(): Promise<boolean>;
+    /** Signal for this token */
+    readonly signal: CancellationSignal;
     /**
      * @param initialState which state to initialze this token to
      * - `false`: unset
@@ -111,15 +109,11 @@ export declare class CancellationToken extends ReadonlyCancellationToken {
      * @param observable observable to subscribe. Takes emitted value as state if type is boolean otherwise sets state to true.
      */
     static from(source: Observable<boolean>, config?: ConnectConfig): CancellationToken;
-    private static connect;
-    asAbortSignal(): AbortSignal;
-    asReadonly(): ReadonlyCancellationToken;
-    createChild(config?: ConnectConfig): CancellationToken;
-    connect(child: CancellationToken, config?: ConnectConfig): void;
+    static connect(state$: Observable<boolean>, target: CancellationToken, config?: ConnectConfig): void;
     /**
      * Become a child of the provided parent. Events from the parent are propagated to this token. Events from this token are *not* propagated to the parent.
      */
-    inherit(parent: ReadonlyCancellationToken, config?: ConnectConfig): this;
+    inherit(parent: CancellationToken | CancellationSignal, config?: ConnectConfig): this;
     /**
      * Set this token.
      */
@@ -142,6 +136,4 @@ export declare class CancellationToken extends ReadonlyCancellationToken {
      * Keep in mind that *active* awaits (promise) on this token will throw.
      */
     complete(): void;
-    then<TResult>(onfulfilled?: ((value: void) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
-    subscribe(observer: Partial<Observer<void>>): Subscription;
 }

package/{utils/cancellation-token.js → cancellation/token.js}

@@ -16,38 +16,102 @@ var __copyProps = (to, from2, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cancellation_token_exports = {};
-__export(cancellation_token_exports, {
-  CancellationToken: () => CancellationToken,
-  ReadonlyCancellationToken: () => ReadonlyCancellationToken
+var token_exports = {};
+__export(token_exports, {
+  CancellationSignal: () => CancellationSignal,
+  CancellationToken: () => CancellationToken
 });
-module.exports = __toCommonJS(cancellation_token_exports);
+module.exports = __toCommonJS(token_exports);
 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 ReadonlyCancellationToken {
-}
-class CancellationToken extends ReadonlyCancellationToken {
-  #stateSubject = new import_rxjs.BehaviorSubject(false);
-  state$ = this.#stateSubject.pipe((0, import_rxjs.distinctUntilChanged)());
+var import_noop2 = require("../utils/noop.js");
+var import_type_guards = require("../utils/type-guards.js");
+class CancellationSignal {
+  #stateSubject;
+  /**
+   * Observable which emits the current state and every state change.
+   */
+  state$ = (0, import_rxjs.defer)(() => this.#stateSubject);
+  /**
+   * Observable which emits when this token is set.
+   */
   set$ = this.state$.pipe((0, import_rxjs.filter)((state) => state), (0, import_rxjs.map)(() => void 0));
+  /**
+   * Observable which emits when this token is unset.
+   */
   unset$ = this.state$.pipe((0, import_rxjs.filter)((state) => !state), (0, import_rxjs.map)(() => void 0));
+  /**
+   * Returns a promise which is resolved when this token changes its state.
+   */
+  get $state() {
+    return (0, import_rxjs.firstValueFrom)(this.state$.pipe((0, import_rxjs.skip)(1)));
+  }
+  /**
+   * Returns a promise which is resolved when this token is set.
+   */
+  get $set() {
+    return (0, import_rxjs.firstValueFrom)(this.set$);
+  }
+  /**
+   * Returns a promise which is resolved when this token is unset.
+   */
+  get $unset() {
+    return (0, import_rxjs.firstValueFrom)(this.unset$);
+  }
+  get state() {
+    return this.#stateSubject.value;
+  }
+  /**
+   * Whether this token is set.
+   */
   get isSet() {
     return this.#stateSubject.value;
   }
+  /**
+   * Whether this token is unset.
+   */
   get isUnset() {
     return !this.#stateSubject.value;
   }
-  get $set() {
-    return (0, import_rxjs.firstValueFrom)(this.set$);
+  constructor(stateSubject) {
+    this.#stateSubject = stateSubject;
   }
-  get $unset() {
-    return (0, import_rxjs.firstValueFrom)(this.unset$);
+  /**
+   * Returns an AbortSignal.
+   */
+  asAbortSignal() {
+    const abortController = new AbortController();
+    this.set$.pipe((0, import_rxjs.first)()).subscribe(() => abortController.abort());
+    return abortController.signal;
   }
-  get $state() {
-    return (0, import_rxjs.firstValueFrom)(this.state$.pipe((0, import_rxjs.skip)(1)));
+  /**
+   * Create a new token and connect it to this instance.
+   * @see {@link connect}
+   */
+  createChild(config) {
+    const child = new CancellationToken();
+    this.connect(child, config);
+    return child;
   }
+  /**
+   * Propagate events from this instance to `target`. Events from the `target` are *not* propagated to this instance.
+   * @param target receiver to connect
+   */
+  connect(target, config) {
+    CancellationToken.connect(this.state$, target, config);
+  }
+  async then(onfulfilled) {
+    await this.$set;
+    return onfulfilled?.();
+  }
+  subscribe(observer) {
+    return this.set$.subscribe(observer);
+  }
+}
+class CancellationToken extends CancellationSignal {
+  #stateSubject;
+  /** Signal for this token */
+  signal;
   /**
    * @param initialState which state to initialze this token to
    * - `false`: unset
@@ -55,8 +119,10 @@ class CancellationToken extends ReadonlyCancellationToken {
    * @default false
    */
   constructor(initialState = false) {
-    super();
-    this.#stateSubject.next(initialState);
+    const stateSubject = new import_rxjs.BehaviorSubject(initialState);
+    super(stateSubject);
+    this.#stateSubject = new import_rxjs.BehaviorSubject(initialState);
+    this.signal = new CancellationSignal(this.#stateSubject);
   }
   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));
@@ -64,10 +130,10 @@ class CancellationToken extends ReadonlyCancellationToken {
     CancellationToken.connect(source$, token, config);
     return token;
   }
-  static connect(stateObservable, target, config = {}) {
+  static connect(state$, target, config = {}) {
     const { set = true, unset = true, complete = true, error = true, immediate = true, once = false } = config;
-    const state$ = stateObservable.pipe(immediate ? (0, import_noop.noopOperator)() : (0, import_rxjs.skip)(1), set && unset ? (0, import_noop.noopOperator)() : set ? (0, import_rxjs.filter)((state) => state) : unset ? (0, import_rxjs.filter)((state) => !state) : (0, import_rxjs.filter)(() => false), once ? (0, import_rxjs.take)(1) : (0, import_noop.noopOperator)());
-    const subscription = state$.subscribe({
+    const stateObservable = state$.pipe(immediate ? (0, import_noop.noopOperator)() : (0, import_rxjs.skip)(1), set && unset ? (0, import_noop.noopOperator)() : set ? (0, import_rxjs.filter)((state) => state) : unset ? (0, import_rxjs.filter)((state) => !state) : (0, import_rxjs.filter)(() => false), once ? (0, import_rxjs.take)(1) : (0, import_noop.noopOperator)());
+    const subscription = stateObservable.subscribe({
       next: (state) => target.setState(state),
       error: error ? (errorValue) => target.error(errorValue) : import_noop2.noop,
       complete: complete ? () => target.complete() : import_noop2.noop
@@ -77,40 +143,25 @@ class CancellationToken extends ReadonlyCancellationToken {
       complete: () => subscription.unsubscribe()
     });
   }
-  asAbortSignal() {
-    const abortController = new AbortController();
-    this.set$.pipe((0, import_rxjs.first)()).subscribe(() => abortController.abort());
-    return abortController.signal;
-  }
-  asReadonly() {
-    return this;
-  }
-  createChild(config) {
-    const child = new CancellationToken();
-    this.connect(child, config);
-    return child;
-  }
-  connect(child, config) {
-    CancellationToken.connect(this.state$, child, config);
-  }
   /**
    * Become a child of the provided parent. Events from the parent are propagated to this token. Events from this token are *not* propagated to the parent.
    */
   inherit(parent, config) {
-    CancellationToken.connect(parent.state$, this, config);
+    const state$ = (parent instanceof CancellationToken ? parent.signal : parent).state$;
+    CancellationToken.connect(state$, this, config);
     return this;
   }
   /**
    * Set this token.
    */
   set() {
-    this.#stateSubject.next(true);
+    this.setState(true);
   }
   /**
    * Unset this token.
    */
   unset() {
-    this.#stateSubject.next(false);
+    this.setState(false);
   }
   /**
    * Set the state.
@@ -132,11 +183,4 @@ class CancellationToken extends ReadonlyCancellationToken {
   complete() {
     this.#stateSubject.complete();
   }
-  async then(onfulfilled) {
-    await this.$set;
-    return onfulfilled?.();
-  }
-  subscribe(observer) {
-    return this.set$.subscribe(observer);
-  }
 }

package/core.d.ts

@@ -1,14 +1,17 @@
+import type { CancellationSignal } from './cancellation/token.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;
+/**
+ * @deprecated Should be avoided. Use `Application` scoped injector instead.
+ */
+export declare function getGlobalInjector(): Injector;
 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, cancellationToken: ReadonlyCancellationToken, maxTries?: number): Promise<void>;
+export declare function connect(name: string, connectFunction: (() => Promise<any>), logger: Logger, cancellationSignal: CancellationSignal, maxTries?: number): Promise<void>;
 export type CoreConfiguration = {
     production?: boolean;
     logger?: InjectionToken<Logger, LoggerArgument>;

package/core.js

@@ -22,9 +22,9 @@ __export(core_exports, {
   configureTstdl: () => configureTstdl,
   connect: () => connect,
   enableProdMode: () => enableProdMode,
+  getGlobalInjector: () => getGlobalInjector,
   isDevMode: () => isDevMode,
-  isProdMode: () => isProdMode,
-  rootInjector: () => rootInjector
+  isProdMode: () => isProdMode
 });
 module.exports = __toCommonJS(core_exports);
 var import_injector = require("./injector/injector.js");
@@ -35,8 +35,14 @@ var import_process_shutdown = require("./process-shutdown.js");
 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");
+let globalInjector;
 let _isDevMode = true;
+function getGlobalInjector() {
+  if ((0, import_type_guards.isUndefined)(globalInjector)) {
+    globalInjector = new import_injector.Injector("GlobalInjector");
+  }
+  return globalInjector;
+}
 function isDevMode() {
   return _isDevMode;
 }
@@ -46,10 +52,10 @@ function isProdMode() {
 function enableProdMode() {
   _isDevMode = false;
 }
-async function connect(name, connectFunction, logger, cancellationToken, maxTries = 5) {
+async function connect(name, connectFunction, logger, cancellationSignal, maxTries = 5) {
   let triesLeft = maxTries;
   let success = false;
-  while (!success && cancellationToken.isUnset && triesLeft-- > 0) {
+  while (!success && cancellationSignal.isUnset && triesLeft-- > 0) {
     try {
       logger.verbose(`connecting to ${name}...`);
       await connectFunction();
@@ -70,7 +76,7 @@ function configureTstdl(config = {}) {
   if (config.production == true) {
     enableProdMode();
   }
-  const logger = rootInjector.resolve(CORE_LOGGER);
+  const logger = getGlobalInjector().resolve(CORE_LOGGER);
   (0, import_process_shutdown.setProcessShutdownLogger)(logger);
   (0, import_process_shutdown.initializeSignals)();
   import_injector.Injector.register(import_logger2.Logger, { useToken: config.logger ?? import_logger.ConsoleLogger });

package/data-structures/circular-buffer.d.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { Observable } from 'rxjs';
 import { Collection } from './collection.js';
 export declare class CircularBuffer<T> extends Collection<T, CircularBuffer<T>> {
@@ -45,11 +45,11 @@ export declare class CircularBuffer<T> extends Collection<T, CircularBuffer<T>>
     consume(): IterableIterator<T>;
     /**
      * yields all items from the buffer, removes them and waits fore more
-     * @param cancellationToken token to cancel iteration
-     * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationToken} is set
+     * @param cancellationSignal token to cancel iteration
+     * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationSignal} is set
      * @returns
      */
-    consumeAsync(cancellationToken?: ReadonlyCancellationToken, yieldOutstandingItems?: boolean): AsyncIterable<T>;
+    consumeAsync(cancellationSignal?: CancellationSignal, yieldOutstandingItems?: boolean): AsyncIterable<T>;
     protected _clear(): void;
     private increaseBufferSizeIfNeeded;
     private resize;

package/data-structures/circular-buffer.js

@@ -21,7 +21,7 @@ __export(circular_buffer_exports, {
   CircularBuffer: () => CircularBuffer
 });
 module.exports = __toCommonJS(circular_buffer_exports);
-var import_cancellation_token = require("../utils/cancellation-token.js");
+var import_token = require("../cancellation/token.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_rxjs = require("rxjs");
 var import_collection = require("./collection.js");
@@ -133,7 +133,7 @@ class CircularBuffer extends import_collection.Collection {
   }
   clone(newMaxBufferSize = this.maxBufferSize) {
     if ((0, import_type_guards.isDefined)(newMaxBufferSize) && newMaxBufferSize < this.size) {
-      throw new Error("newSize must be equal or larger to current size");
+      throw new Error("newSize must be equal or larger to current size.");
     }
     const cloned = new CircularBuffer(newMaxBufferSize);
     cloned.addMany(this);
@@ -147,7 +147,7 @@ class CircularBuffer extends import_collection.Collection {
     try {
       for (let i = 0; i < size; i++) {
         if (modified) {
-          throw new Error("buffer was modified while being iterated");
+          throw new Error("Buffer was modified while being iterated.");
         }
         yield this.backingArray[readIndex];
         readIndex = (readIndex + 1) % this.bufferSize;
@@ -164,19 +164,19 @@ class CircularBuffer extends import_collection.Collection {
   }
   /**
    * yields all items from the buffer, removes them and waits fore more
-   * @param cancellationToken token to cancel iteration
-   * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationToken} is set
+   * @param cancellationSignal token to cancel iteration
+   * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationSignal} is set
    * @returns
    */
-  async *consumeAsync(cancellationToken = new import_cancellation_token.CancellationToken(), yieldOutstandingItems = true) {
+  async *consumeAsync(cancellationSignal = new import_token.CancellationToken(), yieldOutstandingItems = true) {
     while (true) {
       if (this.isEmpty) {
-        await (0, import_rxjs.firstValueFrom)((0, import_rxjs.race)([this.onItems$, cancellationToken]));
+        await (0, import_rxjs.firstValueFrom)((0, import_rxjs.race)([this.onItems$, cancellationSignal]));
       }
-      while (this.size > 0 && (cancellationToken.isUnset || yieldOutstandingItems)) {
+      while (this.size > 0 && (cancellationSignal.isUnset || yieldOutstandingItems)) {
         yield this.tryRemove();
       }
-      if (cancellationToken.isSet) {
+      if (cancellationSignal.isSet) {
         return;
       }
     }
@@ -198,7 +198,7 @@ class CircularBuffer extends import_collection.Collection {
   }
   resize(size) {
     if (size < this.size) {
-      throw new Error("buffer has more items than it would have capacity after resize");
+      throw new Error("Buffer has more items than it would have capacity after resize.");
     }
     let newBackingArray;
     if (this.size > 0) {

package/database/mongo/module.js

@@ -49,8 +49,8 @@ import_injector.Injector.registerSingleton(import_classes.MongoClient, {
     context.data.url = url;
     return client;
   },
-  async afterResolve(client, _argument, { cancellationToken, data: { url, logger } }) {
-    await (0, import_core.connect)(`mongo at ${url}`, async () => client.connect(), logger, cancellationToken);
+  async afterResolve(client, _argument, { cancellationSignal, data: { url, logger } }) {
+    await (0, import_core.connect)(`mongo at ${url}`, async () => client.connect(), logger, cancellationSignal);
   }
 }, {
   defaultArgumentProvider: () => mongoModuleConfig.defaultConnection,

package/disposable/async-disposer.d.ts

@@ -1,5 +1,5 @@
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
-import { CancellationToken } from '../utils/cancellation-token.js';
+import type { CancellationSignal } from '../cancellation/token.js';
+import { CancellationToken } from '../cancellation/token.js';
 import type { AsyncDisposable, Disposable } from './disposable.js';
 declare const deferrerToken: unique symbol;
 export type AsyncDisposeTaskFunction = () => any;
@@ -13,8 +13,8 @@ export type Deferrer = {
 };
 export declare class AsyncDisposer implements AsyncDisposable, AsyncDisposableStack {
     #private;
-    get disposingToken(): ReadonlyCancellationToken;
-    get disposedToken(): ReadonlyCancellationToken;
+    get disposingSignal(): CancellationSignal;
+    get disposedSignal(): CancellationSignal;
     get disposing(): boolean;
     get disposed(): boolean;
     readonly [Symbol.toStringTag] = "AsyncDisposable";