@tstdl/base 0.86.1 → 0.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.86.1",
+  "version": "0.87.0",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -34,8 +34,8 @@
     "@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.48",
@@ -48,7 +48,7 @@
   "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/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/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

@@ -48,9 +48,9 @@ import_injector.Injector.registerSingleton(import_elasticsearch.Client, {
     context.addDisposeHandler(async () => client.close().then(() => context.data.logger.info("closed connection")));
     return client;
   },
-  async afterResolve(client, options, { cancellationToken, data: { logger } }) {
+  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")), logger, cancellationToken);
+    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/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';

package/utils/index.js

@@ -23,7 +23,6 @@ __reExport(utils_exports, require("./base64.js"), module.exports);
 __reExport(utils_exports, require("./benchmark.js"), module.exports);
 __reExport(utils_exports, require("./binary-search.js"), module.exports);
 __reExport(utils_exports, require("./binary.js"), module.exports);
-__reExport(utils_exports, require("./cancellation-token.js"), module.exports);
 __reExport(utils_exports, require("./clone.js"), module.exports);
 __reExport(utils_exports, require("./comparison.js"), module.exports);
 __reExport(utils_exports, require("./date-time.js"), module.exports);

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

@@ -1,2 +1,2 @@
-import type { ReadonlyCancellationToken } from '../cancellation-token.js';
-export declare function takeUntil<T>(iterable: Iterable<T>, cancellationToken: ReadonlyCancellationToken): IterableIterator<T>;
+import type { CancellationSignal } from '../../cancellation/token.js';
+export declare function takeUntil<T>(iterable: Iterable<T>, cancellationSignal: CancellationSignal): IterableIterator<T>;

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

@@ -21,9 +21,9 @@ __export(take_until_exports, {
   takeUntil: () => takeUntil
 });
 module.exports = __toCommonJS(take_until_exports);
-function* takeUntil(iterable, cancellationToken) {
+function* takeUntil(iterable, cancellationSignal) {
   const iterator = iterable[Symbol.iterator]();
-  while (cancellationToken.isUnset) {
+  while (cancellationSignal.isUnset) {
     const result = iterator.next();
     if (result.done == true) {
       return;

package/utils/patch-worker.d.ts

@@ -1,5 +1,5 @@
-import type { Record, StringMap } from '../types.js';
 import type { Observable } from 'rxjs';
+import type { Record, StringMap } from '../types.js';
 export type PatchWorkerOptions<T extends StringMap> = {
     debounceTime?: number;
     retryDelay?: number;

package/utils/patch-worker.js

@@ -22,7 +22,7 @@ __export(patch_worker_exports, {
 });
 module.exports = __toCommonJS(patch_worker_exports);
 var import_rxjs = require("rxjs");
-var import_cancellation_token = require("./cancellation-token.js");
+var import_token = require("../cancellation/token.js");
 var import_timing = require("./timing.js");
 var import_type_guards = require("./type-guards.js");
 const defaultDebounceTime = 5e3;
@@ -37,7 +37,7 @@ class PatchWorker {
     this.options = options;
     this.patchAddedSubject = new import_rxjs.Subject();
     this.handleSubject = new import_rxjs.Subject();
-    this.completeToken = new import_cancellation_token.CancellationToken();
+    this.completeToken = new import_token.CancellationToken();
     this.patch = void 0;
     if ((0, import_type_guards.isDefined)(options.handleOn)) {
       this.handleOn(options.handleOn);

package/utils/periodic-reporter.js

@@ -22,8 +22,8 @@ __export(periodic_reporter_exports, {
 });
 module.exports = __toCommonJS(periodic_reporter_exports);
 var import_rxjs = require("rxjs");
+var import_token = require("../cancellation/token.js");
 var import_deferred_promise = require("../promise/deferred-promise.js");
-var import_cancellation_token = require("./cancellation-token.js");
 var import_timing = require("./timing.js");
 class PeriodicReporter {
   reportSubject;
@@ -43,7 +43,7 @@ class PeriodicReporter {
     this.ignoreZero = ignoreZero;
     this.resetAfterReport = resetAfterReport;
     this.running = false;
-    this.stopToken = new import_cancellation_token.CancellationToken();
+    this.stopToken = new import_token.CancellationToken();
     this.stopped = new import_deferred_promise.DeferredPromise();
     this.reportSubject = new import_rxjs.Subject();
   }

package/utils/timing.d.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyCancellationToken } from './cancellation-token.js';
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { ValueOrProvider } from './value-or-provider.js';
 /** timeout for specified duration */
 export declare function timeout(milliseconds?: number, options?: {
@@ -7,9 +7,9 @@ export declare function timeout(milliseconds?: number, options?: {
 /** timeout until specified time */
 export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
 /** timeout for specified duration */
-export declare function cancelableTimeout(milliseconds: number, cancelToken: ReadonlyCancellationToken): Promise<boolean>;
+export declare function cancelableTimeout(milliseconds: number, cancelSignal: CancellationSignal): Promise<boolean>;
 /** timeout until specified time */
-export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelToken: ReadonlyCancellationToken): Promise<boolean>;
+export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: CancellationSignal): Promise<boolean>;
 export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
     errorMessage?: string;
 }): Promise<T>;

package/utils/timing.js

@@ -29,8 +29,8 @@ __export(timing_exports, {
   withTimeout: () => withTimeout
 });
 module.exports = __toCommonJS(timing_exports);
-var import_timeout_error = require("../error/timeout.error.js");
 var import_rxjs = require("rxjs");
+var import_timeout_error = require("../error/timeout.error.js");
 var import_throw = require("./throw.js");
 var import_value_or_provider = require("./value-or-provider.js");
 async function timeout(milliseconds = 0, options) {
@@ -47,16 +47,16 @@ async function timeoutUntil(timestamp) {
   const left = timestamp.valueOf() - Date.now();
   return timeout(left);
 }
-async function cancelableTimeout(milliseconds, cancelToken) {
+async function cancelableTimeout(milliseconds, cancelSignal) {
   return (0, import_rxjs.firstValueFrom)((0, import_rxjs.race)([
     (0, import_rxjs.timer)(milliseconds).pipe((0, import_rxjs.map)(() => false)),
-    cancelToken.set$.pipe((0, import_rxjs.map)(() => true))
+    cancelSignal.set$.pipe((0, import_rxjs.map)(() => true))
     // eslint-disable-line @typescript-eslint/no-unsafe-argument
   ]));
 }
-async function cancelableTimeoutUntil(timestamp, cancelToken) {
+async function cancelableTimeoutUntil(timestamp, cancelSignal) {
   const left = timestamp.valueOf() - Date.now();
-  return cancelableTimeout(left, cancelToken);
+  return cancelableTimeout(left, cancelSignal);
 }
 async function withTimeout(milliseconds, promiseOrProvider, options) {
   const abortController = new AbortController();