@tstdl/base 0.86.0 → 0.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.86.0",
+  "version": "0.87.0",
   "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",
@@ -33,21 +34,21 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "6.4",
-    "@typescript-eslint/parser": "6.4",
+    "@typescript-eslint/eslint-plugin": "6.5",
+    "@typescript-eslint/parser": "6.5",
     "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",
     "@koa/router": "^12.0",
-    "@tstdl/angular": "^0.86",
+    "@tstdl/angular": "^0.87",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",

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/process-shutdown.d.ts

@@ -1,6 +1,8 @@
+import type { CancellationSignal } from './cancellation/index.js';
+import { CancellationToken } from './cancellation/index.js';
 import type { Logger } from './logger/index.js';
-import { CancellationToken } from './utils/cancellation-token.js';
-export declare const shutdownToken: CancellationToken;
+export declare function getShutdownToken(): CancellationToken;
+export declare function getShutdownSignal(): CancellationSignal;
 export declare function setProcessShutdownLogger(shutdownLogger: Logger): void;
 export declare function requestShutdown(exitCode?: number): void;
 export declare function forceShutdown(exitCode?: number): void;

package/process-shutdown.js

@@ -19,17 +19,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var process_shutdown_exports = {};
 __export(process_shutdown_exports, {
   forceShutdown: () => forceShutdown,
+  getShutdownSignal: () => getShutdownSignal,
+  getShutdownToken: () => getShutdownToken,
   initializeSignals: () => initializeSignals,
   requestShutdown: () => requestShutdown,
-  setProcessShutdownLogger: () => setProcessShutdownLogger,
-  shutdownToken: () => shutdownToken
+  setProcessShutdownLogger: () => setProcessShutdownLogger
 });
 module.exports = __toCommonJS(process_shutdown_exports);
-var import_cancellation_token = require("./utils/cancellation-token.js");
+var import_cancellation = require("./cancellation/index.js");
 var import_type_guards = require("./utils/type-guards.js");
 const quitSignals = ["SIGTERM", "SIGINT", "SIGHUP", "SIGBREAK"];
 const quitEvents = ["uncaughtException", "unhandledRejection", "rejectionHandled"];
-const shutdownToken = new import_cancellation_token.CancellationToken();
+let shutdownToken;
+function getShutdownToken() {
+  if ((0, import_type_guards.isUndefined)(shutdownToken)) {
+    shutdownToken = new import_cancellation.CancellationToken();
+  }
+  return shutdownToken;
+}
+function getShutdownSignal() {
+  return getShutdownToken().signal;
+}
 let logger;
 function setProcessShutdownLogger(shutdownLogger) {
   logger = shutdownLogger;
@@ -40,7 +50,7 @@ function requestShutdown(exitCode = 1) {
     return;
   }
   shutdownRequested = true;
-  shutdownToken.set();
+  getShutdownToken().set();
   const timeout = setTimeout(() => {
     logger.warn("forcefully quitting after 20 seconds...");
     setTimeout(() => process.exit(exitCode), 1);

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/queue/mongo/queue.d.ts

@@ -1,8 +1,8 @@
+import type { CancellationSignal } from '../../cancellation/index.js';
 import { Lock } from '../../lock/index.js';
 import { MessageBusProvider } from '../../message-bus/index.js';
-import type { EnqueueManyItem, EnqueueOptions, Job, JobTag, QueueConfig } from '../../queue/index.js';
-import { Queue } from '../../queue/index.js';
-import type { ReadonlyCancellationToken } from '../../utils/cancellation-token.js';
+import type { EnqueueManyItem, EnqueueOptions, Job, JobTag } from '../../queue/index.js';
+import { Queue, type QueueConfig } from '../../queue/index.js';
 import { MongoJobRepository } from './mongo-job.repository.js';
 export declare class MongoQueue<T = unknown> extends Queue<T> {
     private readonly repository;
@@ -27,6 +27,6 @@ export declare class MongoQueue<T = unknown> extends Queue<T> {
     dequeueMany(count: number): Promise<Job<T>[]>;
     acknowledge(job: Job<T>): Promise<void>;
     acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    getConsumer(cancellationToken: ReadonlyCancellationToken): AsyncIterableIterator<Job<T>>;
-    getBatchConsumer(size: number, cancellationToken: ReadonlyCancellationToken): AsyncIterableIterator<Job<T>[]>;
+    getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
+    getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
 }

package/queue/mongo/queue.js

@@ -21,6 +21,7 @@ __export(queue_exports, {
   MongoQueue: () => MongoQueue
 });
 module.exports = __toCommonJS(queue_exports);
+var import_cancellation = require("../../cancellation/index.js");
 var import_id = require("../../database/id.js");
 var import_decorators = require("../../injector/decorators.js");
 var import_lock = require("../../lock/index.js");
@@ -28,7 +29,6 @@ var import_message_bus = require("../../message-bus/index.js");
 var import_queue = require("../../queue/index.js");
 var import_alphabet = require("../../utils/alphabet.js");
 var import_backoff = require("../../utils/backoff.js");
-var import_cancellation_token = require("../../utils/cancellation-token.js");
 var import_date_time = require("../../utils/date-time.js");
 var import_property_name = require("../../utils/object/property-name.js");
 var import_random = require("../../utils/random.js");
@@ -215,9 +215,9 @@ let MongoQueue = class MongoQueue2 extends import_queue.Queue {
     const jobIds = jobs.map((job) => job.id);
     return this.cancelMany(jobIds);
   }
-  async *getConsumer(cancellationToken) {
-    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
-    for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
+  async *getConsumer(cancellationSignal) {
+    const continueToken = import_cancellation.CancellationToken.from(this.messageBus.allMessages$);
+    for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationSignal)) {
       const job = await this.dequeue();
       if (job != void 0) {
         yield job;
@@ -227,9 +227,9 @@ let MongoQueue = class MongoQueue2 extends import_queue.Queue {
     }
     continueToken.complete();
   }
-  async *getBatchConsumer(size, cancellationToken) {
-    const continueToken = import_cancellation_token.CancellationToken.from(this.messageBus.allMessages$);
-    for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationToken)) {
+  async *getBatchConsumer(size, cancellationSignal) {
+    const continueToken = import_cancellation.CancellationToken.from(this.messageBus.allMessages$);
+    for await (const backoff of (0, import_backoff.backoffGenerator)(backoffOptions, cancellationSignal)) {
       const jobs = await this.dequeueMany(size);
       if (jobs.length > 0) {
         yield jobs;

package/queue/queue.d.ts

@@ -1,6 +1,6 @@
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { Resolvable } from '../injector/interfaces.js';
 import { resolveArgumentType } from '../injector/interfaces.js';
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
 export type JobTag = string | number | null;
 export type Job<T> = {
@@ -53,6 +53,6 @@ export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
     abstract dequeueMany(count: number): Promise<Job<T>[]>;
     abstract acknowledge(job: Job<T>): Promise<void>;
     abstract acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    abstract getConsumer(cancellationToken: ReadonlyCancellationToken): AsyncIterableIterator<Job<T>>;
-    abstract getBatchConsumer(size: number, cancellationToken: ReadonlyCancellationToken): AsyncIterableIterator<Job<T>[]>;
+    abstract getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
+    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
 }

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, { cancellationSignal, 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, cancellationSignal);
   },
   defaultArgumentProvider() {
     return elasticsearchModuleConfig.defaultOptions;

package/signals/to-signal-2.d.ts

@@ -1,14 +1,16 @@
-import type { Subscribable } from 'rxjs';
+import type { Observable, Subscribable } from 'rxjs';
 import type { Signal, ToSignalOptions } from './api.js';
+type ToSignalInput<T> = Observable<T> | Subscribable<T>;
 export type ToSignal2Options<T> = ToSignalOptions<T> & {
     /** defer subscription until signal is used */
     lazy?: boolean;
 };
 /** like `toSignal`, except that it uses untracked internal operations (required for some scenarios, but might be less safe in terms of bugs catching) and has the ability to subscribe lazily */
-export declare function toSignal2<T>(source: Subscribable<T>): Signal<T | undefined>;
-export declare function toSignal2<T>(source: Subscribable<T>, options: ToSignal2Options<undefined> & {
+export declare function toSignal2<T>(source: ToSignalInput<T>): Signal<T | undefined>;
+export declare function toSignal2<T>(source: ToSignalInput<T>, options: ToSignal2Options<undefined> & {
     requireSync: true;
 }): Signal<T>;
-export declare function toSignal2<T, const I = undefined>(source: Subscribable<T>, options: ToSignal2Options<I> & {
+export declare function toSignal2<T, const I = undefined>(source: ToSignalInput<T>, options: ToSignal2Options<I> & {
     requireSync?: false;
 }): Signal<T | I>;
+export {};

package/tsconfig.json

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

package/utils/async-iterable-helpers/buffer.js

@@ -21,13 +21,13 @@ __export(buffer_exports, {
   bufferAsync: () => bufferAsync
 });
 module.exports = __toCommonJS(buffer_exports);
+var import_token = require("../../cancellation/token.js");
 var import_circular_buffer = require("../../data-structures/circular-buffer.js");
-var import_cancellation_token = require("../cancellation-token.js");
 var import_object = require("../object/object.js");
 var import_take_until = require("./take-until.js");
 async function* bufferAsync(iterable, size) {
   const buffer = new import_circular_buffer.CircularBuffer(Math.max(1, size));
-  const consumerEndedToken = new import_cancellation_token.CancellationToken();
+  const consumerEndedToken = new import_token.CancellationToken();
   let consumerHasError = false;
   let consumerError;
   void (async () => {

package/utils/async-iterable-helpers/observable-iterable.js

@@ -21,13 +21,13 @@ __export(observable_iterable_exports, {
   observableAsyncIterable: () => observableAsyncIterable
 });
 module.exports = __toCommonJS(observable_iterable_exports);
+var import_token = require("../../cancellation/token.js");
 var import_rxjs = require("rxjs");
 var import_observable_array = require("../../collections/observable/observable-array.js");
-var import_cancellation_token = require("../cancellation-token.js");
 async function* observableAsyncIterable(observable) {
   const buffer = new import_observable_array.ObservableArray();
-  const completeToken = new import_cancellation_token.CancellationToken();
-  const errorToken = new import_cancellation_token.CancellationToken();
+  const completeToken = new import_token.CancellationToken();
+  const errorToken = new import_token.CancellationToken();
   let error;
   const subscription = observable.subscribe({
     next: (value) => buffer.add(value),

package/utils/async-iterable-helpers/take-until.d.ts

@@ -1,3 +1,3 @@
+import type { CancellationSignal } from '../../cancellation/token.js';
 import type { AnyIterable } from '../any-iterable-iterator.js';
-import type { ReadonlyCancellationToken } from '../cancellation-token.js';
-export declare function takeUntilAsync<T>(iterable: AnyIterable<T>, cancellationToken: ReadonlyCancellationToken): AsyncIterableIterator<T>;
+export declare function takeUntilAsync<T>(iterable: AnyIterable<T>, cancellationSignal: CancellationSignal): AsyncIterableIterator<T>;

package/utils/async-iterable-helpers/take-until.js

@@ -23,23 +23,23 @@ __export(take_until_exports, {
 module.exports = __toCommonJS(take_until_exports);
 var import_rxjs = require("rxjs");
 var import_is_async_iterable = require("./is-async-iterable.js");
-function takeUntilAsync(iterable, cancellationToken) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, cancellationToken) : sync(iterable, cancellationToken);
+function takeUntilAsync(iterable, cancellationSignal) {
+  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, cancellationSignal) : sync(iterable, cancellationSignal);
 }
-async function* sync(iterable, cancellationToken) {
-  if (cancellationToken.isSet) {
+async function* sync(iterable, cancellationSignal) {
+  if (cancellationSignal.isSet) {
     return;
   }
   for (const item of iterable) {
     yield item;
-    if (cancellationToken.isSet) {
+    if (cancellationSignal.isSet) {
       break;
     }
   }
 }
-async function* async(iterable, cancellationToken) {
+async function* async(iterable, cancellationSignal) {
   const iterator = iterable[Symbol.asyncIterator]();
-  const cancel$ = cancellationToken.set$.pipe((0, import_rxjs.map)(() => ({ done: true, value: void 0 })));
+  const cancel$ = cancellationSignal.set$.pipe((0, import_rxjs.map)(() => ({ done: true, value: void 0 })));
   try {
     while (true) {
       const result = await (0, import_rxjs.firstValueFrom)((0, import_rxjs.race)([iterator.next(), cancel$]));

package/utils/backoff.d.ts

@@ -1,5 +1,5 @@
-import type { ReadonlyCancellationToken } from './cancellation-token.js';
-import { CancellationToken } from './cancellation-token.js';
+import type { CancellationSignal } from '../cancellation/token.js';
+import { CancellationToken } from '../cancellation/token.js';
 export type BackoffStrategy = 'linear' | 'exponential';
 export type BackoffOptions = {
     /**
@@ -51,22 +51,22 @@ export declare class BackoffHelper {
  * @param loopFunction function to call
  */
 export declare function autoBackoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
-    cancellationToken?: ReadonlyCancellationToken;
+    cancellationSignal?: CancellationSignal;
     errorHandler?: (error: Error) => void;
 }): Promise<void>;
 /**
  * runs a function until token is set or controller returns.
  * @param options backoff options
- * @param cancellationToken token to cancel loop
+ * @param cancellationToken signal to cancel loop
  * @param loopFunction function to call
  */
 export declare function backoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
-    cancellationToken?: ReadonlyCancellationToken;
+    cancellationSignal?: CancellationSignal;
 }): Promise<void>;
 /**
  * generates endless function which, when called, backs off next iteration
  * @param options backoff options
- * @param cancellationToken token to cancel loop
+ * @param cancellationSignal signal to cancel loop
  * @example
  * for await (const backoff of backoffGenerator(options, token)) {
  *  if (iWantToBackoff) {
@@ -74,4 +74,4 @@ export declare function backoffLoop(options: BackoffOptions, loopFunction: Backo
  *  }
  * }
  */
-export declare function backoffGenerator(options: BackoffOptions, cancellationToken: ReadonlyCancellationToken): AsyncIterableIterator<BackoffGeneratorYield>;
+export declare function backoffGenerator(options: BackoffOptions, cancellationSignal: CancellationSignal): AsyncIterableIterator<BackoffGeneratorYield>;

package/utils/backoff.js

@@ -24,7 +24,7 @@ __export(backoff_exports, {
   backoffLoop: () => backoffLoop
 });
 module.exports = __toCommonJS(backoff_exports);
-var import_cancellation_token = require("./cancellation-token.js");
+var import_token = require("../cancellation/token.js");
 var import_noop = require("./noop.js");
 var import_timing = require("./timing.js");
 var import_type_guards = require("./type-guards.js");
@@ -58,11 +58,11 @@ async function autoBackoffLoop(options, loopFunction, extras) {
       errorHandler(error);
       controller.backoff();
     }
-  }, { cancellationToken: extras?.cancellationToken });
+  }, { cancellationSignal: extras?.cancellationSignal });
 }
 async function backoffLoop(options, loopFunction, extras) {
   const backoffHelper = new BackoffHelper(options);
-  const loopCancellationToken = extras?.cancellationToken?.createChild({ unset: false, complete: false }) ?? new import_cancellation_token.CancellationToken();
+  const loopCancellationToken = extras?.cancellationSignal?.createChild({ unset: false, complete: false }) ?? new import_token.CancellationToken();
   let backoff = false;
   const controller = {
     backoff: () => backoff = true,
@@ -82,15 +82,15 @@ async function backoffLoop(options, loopFunction, extras) {
     }
   }
 }
-async function* backoffGenerator(options, cancellationToken) {
+async function* backoffGenerator(options, cancellationSignal) {
   const backoffHelper = new BackoffHelper(options);
-  while (cancellationToken.isUnset) {
+  while (cancellationSignal.isUnset) {
     let backoff = false;
-    let timeoutToken = cancellationToken;
+    let timeoutToken = cancellationSignal;
     const backoffFunction = (continueToken) => {
       backoff = true;
       if ((0, import_type_guards.isDefined)(continueToken)) {
-        timeoutToken = cancellationToken.createChild().inherit(continueToken);
+        timeoutToken = cancellationSignal.createChild().inherit(continueToken);
       }
     };
     yield backoffFunction;

package/utils/event-loop.d.ts

@@ -1,4 +1,4 @@
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { Logger } from '../logger/index.js';
-import type { ReadonlyCancellationToken } from './cancellation-token.js';
 export declare function measureEventLoopDelay(): Promise<number>;
-export declare function runEventLoopWatcher(logger: Logger, cancellationToken: ReadonlyCancellationToken): void;
+export declare function runEventLoopWatcher(logger: Logger, cancellationSignal: CancellationSignal): void;

package/utils/event-loop.js

@@ -34,9 +34,9 @@ async function measureEventLoopDelay() {
     });
   });
 }
-function runEventLoopWatcher(logger, cancellationToken) {
+function runEventLoopWatcher(logger, cancellationSignal) {
   const sampler = new import_periodic_sampler.PeriodicSampler(measureEventLoopDelay, 50);
   sampler.watch(0, 100, import_periodic_sampler.AggregationMode.ThirdQuartile).subscribe((delay) => logger.debug(`eventloop: ${(0, import_format.formatDuration)(delay, 2)}`));
   sampler.start();
-  cancellationToken.then(async () => sampler.stop());
+  cancellationSignal.then(async () => sampler.stop());
 }

package/utils/feedable-async-iterable.js

@@ -21,9 +21,9 @@ __export(feedable_async_iterable_exports, {
   FeedableAsyncIterable: () => FeedableAsyncIterable
 });
 module.exports = __toCommonJS(feedable_async_iterable_exports);
-var import_circular_buffer = require("../data-structures/circular-buffer.js");
 var import_rxjs = require("rxjs");
-var import_cancellation_token = require("./cancellation-token.js");
+var import_token = require("../cancellation/token.js");
+var import_circular_buffer = require("../data-structures/circular-buffer.js");
 class FeedableAsyncIterable {
   readSubject;
   closedToken;
@@ -42,7 +42,7 @@ class FeedableAsyncIterable {
   }
   constructor() {
     this.readSubject = new import_rxjs.Subject();
-    this.closedToken = new import_cancellation_token.CancellationToken();
+    this.closedToken = new import_token.CancellationToken();
     this.buffer = new import_circular_buffer.CircularBuffer();
   }
   feed(item) {

package/utils/index.d.ts

@@ -6,7 +6,6 @@ export * from './base64.js';
 export * from './benchmark.js';
 export * from './binary-search.js';
 export * from './binary.js';
-export * from './cancellation-token.js';
 export * from './clone.js';
 export * from './comparison.js';
 export * from './date-time.js';