@tstdl/base 0.86.0 → 0.87.0

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

@@ -45,12 +45,12 @@ import_injector.Injector.registerSingleton(import_classes.MongoClient, {
     const client = new import_classes.MongoClient(url, options);
     client.on("fullsetup", () => logger.verbose("connection setup")).on("reconnect", () => logger.warn("reconnected")).on("timeout", () => logger.warn("connection timed out")).on("close", () => logger.verbose("connection closed"));
     context.addDisposeHandler(async () => client.close());
-    context.context.logger = logger;
-    context.context.url = url;
+    context.data.logger = logger;
+    context.data.url = url;
     return client;
   },
-  async afterResolve(client, _argument, context) {
-    await (0, import_core.connect)(`mongo at ${context.url}`, async () => client.connect(), context.logger);
+  async afterResolve(client, _argument, { cancellationSignal, data: { url, logger } }) {
+    await (0, import_core.connect)(`mongo at ${url}`, async () => client.connect(), logger, cancellationSignal);
   }
 }, {
   defaultArgumentProvider: () => mongoModuleConfig.defaultConnection,
@@ -71,17 +71,17 @@ import_injector.Injector.registerSingleton(import_classes.Collection, {
   useFactory: (config, context) => {
     (0, import_type_guards.assertDefined)(config, "mongo repository config resolve argument missing");
     const database = context.resolve(import_classes.Database, config);
-    context.context.database = database;
+    context.data.database = database;
     return database.collection(config.collection);
   },
-  async afterResolve(_, config, context) {
-    const existingCollections = await context.database.collections();
+  async afterResolve(_, config, { data: { database } }) {
+    const existingCollections = await database.collections();
     for (const collection of existingCollections) {
       if (collection.collectionName == config.collection) {
         return;
       }
     }
-    await context.database.createCollection(config.collection);
+    await database.createCollection(config.collection);
   }
 }, {
   argumentIdentityProvider: JSON.stringify

package/disposable/async-disposer.d.ts

@@ -1,7 +1,6 @@
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
-import { CancellationToken } from '../utils/cancellation-token.js';
+import type { CancellationSignal } from '../cancellation/token.js';
+import { CancellationToken } from '../cancellation/token.js';
 import type { AsyncDisposable, Disposable } from './disposable.js';
-import { disposeAsync } from './disposable.js';
 declare const deferrerToken: unique symbol;
 export type AsyncDisposeTaskFunction = () => any;
 export type AsyncDisposeHandler = AsyncDisposeTaskFunction | Disposable | AsyncDisposable;
@@ -12,16 +11,17 @@ export type Deferrer = {
     [deferrerToken]: CancellationToken;
     yield(): void;
 };
-export declare class AsyncDisposer implements AsyncDisposable {
-    private readonly deferrers;
-    private readonly tasks;
-    readonly _disposingToken: CancellationToken;
-    readonly _disposedToken: CancellationToken;
-    get disposingToken(): ReadonlyCancellationToken;
-    get disposedToken(): ReadonlyCancellationToken;
+export declare class AsyncDisposer implements AsyncDisposable, AsyncDisposableStack {
+    #private;
+    get disposingSignal(): CancellationSignal;
+    get disposedSignal(): CancellationSignal;
     get disposing(): boolean;
     get disposed(): boolean;
+    readonly [Symbol.toStringTag] = "AsyncDisposable";
     constructor();
+    use<T extends globalThis.AsyncDisposable | globalThis.Disposable | null | undefined>(value: T): T;
+    adopt<T>(value: T, onDisposeAsync: (value: T) => void | PromiseLike<void>): T;
+    move(): AsyncDisposableStack;
     getDeferrer(): Deferrer;
     defer<T>(func: () => Promise<T>): Promise<T>;
     /**
@@ -29,7 +29,8 @@ export declare class AsyncDisposer implements AsyncDisposable {
      * @param fnOrDisposable
      */
     add(fnOrDisposable: AsyncDisposeHandler): void;
+    disposeAsync(): Promise<void>;
     dispose(): Promise<void>;
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export {};

package/disposable/async-disposer.js

@@ -22,42 +22,64 @@ __export(async_disposer_exports, {
 });
 module.exports = __toCommonJS(async_disposer_exports);
 var import_type_guards = require("../utils/type-guards.js");
+var import_token = require("../cancellation/token.js");
 var import_multi_error = require("../error/multi.error.js");
-var import_cancellation_token = require("../utils/cancellation-token.js");
 var import_disposable = require("./disposable.js");
 const deferrerToken = Symbol("DeferrerToken");
 class AsyncDisposer {
-  deferrers;
-  tasks;
-  _disposingToken;
-  _disposedToken;
-  get disposingToken() {
-    return this._disposingToken;
+  #disposingToken;
+  #disposedToken;
+  #deferrers;
+  #tasks;
+  get disposingSignal() {
+    return this.#disposingToken;
   }
-  get disposedToken() {
-    return this._disposedToken;
+  get disposedSignal() {
+    return this.#disposedToken;
   }
   get disposing() {
-    return this._disposingToken.isSet;
+    return this.#disposingToken.isSet;
   }
   get disposed() {
-    return this._disposedToken.isSet;
+    return this.#disposedToken.isSet;
   }
+  [Symbol.toStringTag] = "AsyncDisposable";
   constructor() {
-    this.deferrers = /* @__PURE__ */ new Set();
-    this.tasks = [];
-    this._disposingToken = new import_cancellation_token.CancellationToken();
-    this._disposedToken = new import_cancellation_token.CancellationToken();
+    this.#deferrers = /* @__PURE__ */ new Set();
+    this.#tasks = [];
+    this.#disposingToken = new import_token.CancellationToken();
+    this.#disposedToken = new import_token.CancellationToken();
+  }
+  use(value) {
+    if ((0, import_type_guards.isNullOrUndefined)(value)) {
+      return value;
+    }
+    this.add(value);
+    return value;
+  }
+  adopt(value, onDisposeAsync) {
+    this.add(async () => onDisposeAsync(value));
+    return value;
+  }
+  move() {
+    const disposer = new AsyncDisposer();
+    disposer.#tasks = this.#tasks;
+    disposer.#deferrers = this.#deferrers;
+    this.#tasks = [];
+    this.#deferrers = /* @__PURE__ */ new Set();
+    this.#disposingToken.set();
+    this.#disposedToken.set();
+    return disposer;
   }
   getDeferrer() {
     const deferrer = {
-      [deferrerToken]: new import_cancellation_token.CancellationToken(),
+      [deferrerToken]: new import_token.CancellationToken(),
       yield: () => {
         deferrer[deferrerToken].set();
-        this.deferrers.delete(deferrer);
+        this.#deferrers.delete(deferrer);
       }
     };
-    this.deferrers.add(deferrer);
+    this.#deferrers.add(deferrer);
     return deferrer;
   }
   async defer(func) {
@@ -75,24 +97,27 @@ class AsyncDisposer {
    */
   add(fnOrDisposable) {
     const fn = (0, import_disposable.isAsyncDisposable)(fnOrDisposable) ? async () => fnOrDisposable[import_disposable.disposeAsync]() : (0, import_disposable.isDisposable)(fnOrDisposable) ? () => fnOrDisposable[import_disposable.dispose]() : fnOrDisposable;
-    this.tasks.push({ taskFunction: fn });
+    this.#tasks.push({ taskFunction: fn });
+  }
+  async disposeAsync() {
+    await this.dispose();
   }
   async dispose() {
     if (this.disposing) {
-      return this._disposedToken.$set;
+      return this.#disposedToken.$set;
     }
-    this._disposingToken.set();
+    this.#disposingToken.set();
     const errors = [];
-    for (const deferrer of this.deferrers) {
+    for (const deferrer of this.#deferrers) {
       try {
         await deferrer[deferrerToken];
       } catch (error2) {
         errors.push(error2);
       }
     }
-    for (let i = this.tasks.length - 1; i >= 0; i--) {
+    for (let i = this.#tasks.length - 1; i >= 0; i--) {
       try {
-        const task = this.tasks[i];
+        const task = this.#tasks[i];
         await task.taskFunction();
       } catch (error2) {
         errors.push(error2);
@@ -100,12 +125,13 @@ class AsyncDisposer {
     }
     const error = errors.length == 1 ? errors[0] : errors.length > 1 ? new import_multi_error.MultiError(errors, "dispose errors") : void 0;
     if ((0, import_type_guards.isDefined)(error)) {
-      this._disposedToken.error(error);
+      this.#disposedToken.error(error);
       throw error;
     }
-    this._disposedToken.set();
+    this.#disposedToken.set();
+    return void 0;
   }
-  async [import_disposable.disposeAsync]() {
+  async [Symbol.asyncDispose]() {
     return this.dispose();
   }
 }

package/disposable/disposable.d.ts

@@ -1,10 +1,11 @@
-export declare const dispose: unique symbol;
-export declare const disposeAsync: unique symbol;
+export declare const dispose: typeof Symbol.dispose;
+export declare const disposeAsync: typeof Symbol.asyncDispose;
 export interface Disposable {
-    [dispose](): void;
+    [Symbol.dispose](): void;
 }
 export interface AsyncDisposable {
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): PromiseLike<void>;
 }
 export declare function isDisposable(object: any): object is Disposable;
 export declare function isAsyncDisposable(object: any): object is AsyncDisposable;
+export declare function isSyncOrAsyncDisposable(object: any): object is Disposable | AsyncDisposable;

package/disposable/disposable.js

@@ -21,15 +21,19 @@ __export(disposable_exports, {
   dispose: () => dispose,
   disposeAsync: () => disposeAsync,
   isAsyncDisposable: () => isAsyncDisposable,
-  isDisposable: () => isDisposable
+  isDisposable: () => isDisposable,
+  isSyncOrAsyncDisposable: () => isSyncOrAsyncDisposable
 });
 module.exports = __toCommonJS(disposable_exports);
 var import_type_guards = require("../utils/type-guards.js");
-const dispose = Symbol("dispose");
-const disposeAsync = Symbol("disposeAsync");
+const dispose = Symbol.dispose;
+const disposeAsync = Symbol.asyncDispose;
 function isDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[dispose]);
+  return (0, import_type_guards.isFunction)(object?.[Symbol.dispose]);
 }
 function isAsyncDisposable(object) {
-  return (0, import_type_guards.isFunction)(object?.[disposeAsync]);
+  return (0, import_type_guards.isFunction)(object?.[Symbol.asyncDispose]);
+}
+function isSyncOrAsyncDisposable(object) {
+  return (0, import_type_guards.isFunction)(object?.[Symbol.dispose] ?? object?.[Symbol.asyncDispose]);
 }

package/distributed-loop/distributed-loop.d.ts

@@ -1,7 +1,7 @@
+import type { CancellationSignal } from '../cancellation/index.js';
 import { resolveArgumentType } from '../injector/index.js';
 import type { Resolvable } from '../injector/interfaces.js';
 import { LockProvider } from '../lock/index.js';
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import type { LoopController } from './controller.js';
 export type LoopFunction = (controller: LoopController) => any | Promise<any>;
 /** loop key */
@@ -22,11 +22,11 @@ export declare class DistributedLoop implements Resolvable<DistributedLoopArgume
     constructor(key: string, lockProvider: LockProvider);
     /**
      * run the function {@link func} every {@link interval} milliseconds with an accuracy of {@link accuracy}
-     * until {@link cancellationToken} is set or stop on the {@link LoopController} is called
+     * until {@link cancellationSignal} is set or stop on the {@link LoopController} is called
      * @param interval in millseconds
      * @param accuracy in millseconds
      * @param func handler to run
-     * @param cancellationToken token to cancel loop (same as calling stop on the {@link LoopController})
+     * @param cancellationSignal token to cancel loop (same as calling stop on the {@link LoopController})
      */
-    run(interval: number, accuracy: number, func: LoopFunction, cancellationToken?: ReadonlyCancellationToken): LoopController;
+    run(interval: number, accuracy: number, func: LoopFunction, cancellationSignal?: CancellationSignal): LoopController;
 }

package/distributed-loop/distributed-loop.js

@@ -21,10 +21,10 @@ __export(distributed_loop_exports, {
   DistributedLoop: () => DistributedLoop
 });
 module.exports = __toCommonJS(distributed_loop_exports);
+var import_cancellation = require("../cancellation/index.js");
 var import_injector = require("../injector/index.js");
 var import_lock = require("../lock/index.js");
 var import_deferred_promise = require("../promise/deferred-promise.js");
-var import_cancellation_token = require("../utils/cancellation-token.js");
 var import_timer = require("../utils/timer.js");
 var import_timing = require("../utils/timing.js");
 var __decorate = function(decorators, target, key, desc) {
@@ -64,15 +64,15 @@ let DistributedLoop = class DistributedLoop2 {
   }
   /**
    * run the function {@link func} every {@link interval} milliseconds with an accuracy of {@link accuracy}
-   * until {@link cancellationToken} is set or stop on the {@link LoopController} is called
+   * until {@link cancellationSignal} is set or stop on the {@link LoopController} is called
    * @param interval in millseconds
    * @param accuracy in millseconds
    * @param func handler to run
-   * @param cancellationToken token to cancel loop (same as calling stop on the {@link LoopController})
+   * @param cancellationSignal token to cancel loop (same as calling stop on the {@link LoopController})
    */
-  run(interval, accuracy, func, cancellationToken) {
+  run(interval, accuracy, func, cancellationSignal) {
     const $stopped = new import_deferred_promise.DeferredPromise();
-    const stopToken = cancellationToken?.createChild() ?? new import_cancellation_token.CancellationToken();
+    const stopToken = cancellationSignal?.createChild() ?? new import_cancellation.CancellationToken();
     const stopFunction = async () => {
       if (!stopToken.isSet) {
         stopToken.set();
@@ -83,7 +83,7 @@ let DistributedLoop = class DistributedLoop2 {
       stop: stopFunction,
       $stopped
     };
-    (async () => {
+    void (async () => {
       const lock = this.lockProvider.get(this.key);
       const timer = new import_timer.Timer();
       try {

package/enumerable/async-enumerable.d.ts

@@ -1,5 +1,5 @@
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import type { AsyncComparator } from '../utils/sort.js';
 import type { Observable } from 'rxjs';
 import type { AsyncIteratorFunction, AsyncPredicate, AsyncReducer, AsyncRetryPredicate, ParallelizableIteratorFunction, ParallelizablePredicate, ThrottleFunction } from '../utils/async-iterable-helpers/index.js';
@@ -56,7 +56,7 @@ export declare class AsyncEnumerable<T> implements EnumerableMethods, AsyncItera
     sort(comparator?: AsyncComparator<T>): AsyncEnumerable<T>;
     sortToArray(comparator?: AsyncComparator<T>): Promise<T[]>;
     take(count: number): AsyncEnumerable<T>;
-    takeUntil(cancellationToken: ReadonlyCancellationToken): AsyncEnumerable<T>;
+    takeUntil(cancellationSignal: CancellationSignal): AsyncEnumerable<T>;
     takeWhile(yieldLastOnFalse: boolean, predicate: AsyncPredicate<T>): AsyncEnumerable<T>;
     throttle(delayOrThrottleFunction: number | ThrottleFunction): AsyncEnumerable<T>;
     toArray(): Promise<T[]>;

package/enumerable/async-enumerable.js

@@ -198,8 +198,8 @@ class AsyncEnumerable {
     const taken = (0, import_async_iterable_helpers.takeAsync)(this.source, count);
     return new AsyncEnumerable(taken);
   }
-  takeUntil(cancellationToken) {
-    const taken = (0, import_async_iterable_helpers.takeUntilAsync)(this.source, cancellationToken);
+  takeUntil(cancellationSignal) {
+    const taken = (0, import_async_iterable_helpers.takeUntilAsync)(this.source, cancellationSignal);
     return new AsyncEnumerable(taken);
   }
   takeWhile(yieldLastOnFalse, predicate) {

package/enumerable/enumerable.d.ts

@@ -1,5 +1,5 @@
+import type { CancellationSignal } from '../cancellation/token.js';
 import type { Comparator } from '../utils/sort.js';
-import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
 import type { IterableItemMetadata, IteratorFunction, Predicate, Reducer, TypePredicate } from '../utils/iterable-helpers/index.js';
 import { AsyncEnumerable } from './async-enumerable.js';
 import type { EnumerableMethods } from './enumerable-methods.js';
@@ -47,7 +47,7 @@ export declare class Enumerable<T> implements EnumerableMethods, Iterable<T> {
     sort(comparator?: Comparator<T>): Enumerable<T>;
     sortToArray(comparator?: Comparator<T>): T[];
     take(count: number): Enumerable<T>;
-    takeUntil(cancellationToken: ReadonlyCancellationToken): Enumerable<T>;
+    takeUntil(cancellationSignal: CancellationSignal): Enumerable<T>;
     takeWhile(yieldLastOnFalse: boolean, predicate: Predicate<T>): Enumerable<T>;
     toArray(): T[];
     toAsync(): AsyncEnumerable<T>;

package/enumerable/enumerable.js

@@ -169,8 +169,8 @@ class Enumerable {
     const taken = (0, import_iterable_helpers.take)(this.source, count);
     return new Enumerable(taken);
   }
-  takeUntil(cancellationToken) {
-    const taken = (0, import_iterable_helpers.takeUntil)(this.source, cancellationToken);
+  takeUntil(cancellationSignal) {
+    const taken = (0, import_iterable_helpers.takeUntil)(this.source, cancellationSignal);
     return new Enumerable(taken);
   }
   takeWhile(yieldLastOnFalse, predicate) {

package/examples/api/streaming.js

@@ -27,7 +27,7 @@ var __decorate = function(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 (0, import_core.configureTstdl)();
-const logger = import_core.rootInjector.resolve(import_core.CORE_LOGGER);
+const logger = (0, import_core.getGlobalInjector)().resolve(import_core.CORE_LOGGER);
 const streamingApiDefinition = (0, import_api.defineApi)({
   resource: "streams",
   endpoints: {
@@ -69,10 +69,10 @@ StreamingApi = __decorate([
 ], StreamingApi);
 async function* counter() {
   let currentNumber = 0;
-  while (import_application.Application.shutdownToken.isUnset && currentNumber < 10) {
+  while (import_application.Application.shutdownSignal.isUnset && currentNumber < 10) {
     yield `${++currentNumber}`.toString();
     logger.info(`yield: "${currentNumber}"`);
-    await (0, import_timing.cancelableTimeout)(1e3, import_application.Application.shutdownToken);
+    await (0, import_timing.cancelableTimeout)(1e3, import_application.Application.shutdownSignal);
   }
 }
 const StreamingApiClient = (0, import_client.compileClient)(streamingApiDefinition);

package/http/client/adapters/undici-http-client.adapter.js

@@ -83,7 +83,7 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter2 extends import_http
     try {
       const response = await (0, import_undici.request)(httpClientRequest.url, {
         method: httpClientRequest.method,
-        signal: httpClientRequest.abortToken.asAbortSignal(),
+        signal: httpClientRequest.abortSignal.asAbortSignal(),
         headers: httpClientRequest.headers.asNormalizedObject(),
         body,
         headersTimeout: httpClientRequest.timeout,

package/http/client/http-client-request.d.ts

@@ -1,7 +1,7 @@
+import type { CancellationSignal } from '../../cancellation/index.js';
 import type { Disposable } from '../../disposable/index.js';
 import { dispose } from '../../disposable/index.js';
 import type { Record, TypedOmit, UndefinableJson, UndefinableJsonObject } from '../../types.js';
-import type { ReadonlyCancellationToken } from '../../utils/cancellation-token.js';
 import type { HttpFormObject } from '../http-form.js';
 import { HttpForm } from '../http-form.js';
 import type { HttpHeadersObject } from '../http-headers.js';
@@ -28,7 +28,7 @@ export type HttpRequestAuthorization = {
     bearer?: string;
     token?: string;
 };
-export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url' | 'method' | 'abortToken' | 'abort' | 'headers' | 'query' | 'body'>> & {
+export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url' | 'method' | 'abortSignal' | 'abort' | 'headers' | 'query' | 'body'>> & {
     urlParameter?: HttpUrlParametersObject | HttpUrlParameters;
     headers?: HttpHeadersObject | HttpHeaders;
     query?: HttpQueryObject | HttpQuery;
@@ -41,7 +41,7 @@ export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url
         buffer?: Uint8Array;
         stream?: ReadableStream<Uint8Array>;
     };
-    abortToken?: ReadonlyCancellationToken;
+    abortSignal?: CancellationSignal;
 };
 export type HttpRequestCredentials = 'omit' | 'same-origin' | 'include';
 export type HttpClientRequestObject = HttpClientRequestOptions & {
@@ -49,7 +49,7 @@ export type HttpClientRequestObject = HttpClientRequestOptions & {
     method?: HttpMethod;
 };
 export declare class HttpClientRequest implements Disposable {
-    private readonly _abortToken;
+    #private;
     url: string;
     method: HttpMethod;
     headers: HttpHeaders;
@@ -118,7 +118,7 @@ export declare class HttpClientRequest implements Disposable {
     /**
      * can be used to cancel the request. Throws HttpError
      */
-    get abortToken(): ReadonlyCancellationToken;
+    get abortSignal(): CancellationSignal;
     constructor(url: string, method?: HttpMethod, options?: HttpClientRequestOptions);
     constructor(requestObject: HttpClientRequestObject);
     [dispose](): void;

package/http/client/http-client-request.js

@@ -21,8 +21,8 @@ __export(http_client_request_exports, {
   HttpClientRequest: () => HttpClientRequest
 });
 module.exports = __toCommonJS(http_client_request_exports);
+var import_cancellation = require("../../cancellation/index.js");
 var import_disposable = require("../../disposable/index.js");
-var import_cancellation_token = require("../../utils/cancellation-token.js");
 var import_clone = require("../../utils/clone.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_http_form = require("../http-form.js");
@@ -30,7 +30,7 @@ var import_http_headers = require("../http-headers.js");
 var import_http_query = require("../http-query.js");
 var import_http_url_parameters = require("../http-url-parameters.js");
 class HttpClientRequest {
-  _abortToken;
+  #abortToken;
   url;
   method;
   headers;
@@ -99,8 +99,8 @@ class HttpClientRequest {
   /**
    * can be used to cancel the request. Throws HttpError
    */
-  get abortToken() {
-    return this._abortToken.asReadonly();
+  get abortSignal() {
+    return this.#abortToken.signal;
   }
   constructor(urlOrObject, method, options = {}) {
     if ((0, import_type_guards.isString)(urlOrObject)) {
@@ -126,16 +126,16 @@ class HttpClientRequest {
     this.timeout = requestOptions.timeout ?? 3e4;
     this.throwOnNon200 = requestOptions.throwOnNon200 ?? true;
     this.context = requestOptions.context ?? {};
-    this._abortToken = requestOptions.abortToken?.createChild() ?? new import_cancellation_token.CancellationToken();
+    this.#abortToken = requestOptions.abortSignal?.createChild() ?? new import_cancellation.CancellationToken();
   }
   [import_disposable.dispose]() {
-    this._abortToken.set();
-    this._abortToken.complete();
+    this.#abortToken.set();
+    this.#abortToken.complete();
   }
   /** abort the request */
   abort() {
-    this._abortToken.set();
-    this._abortToken.complete();
+    this.#abortToken.set();
+    this.#abortToken.complete();
   }
   clone() {
     const request = new HttpClientRequest(this);

package/http/server/node/node-http-server.js

@@ -32,12 +32,12 @@ __export(node_http_server_exports, {
 });
 module.exports = __toCommonJS(node_http_server_exports);
 var Http = __toESM(require("node:http"), 1);
+var import_cancellation = require("../../../cancellation/index.js");
 var import_disposable = require("../../../disposable/index.js");
 var import_http_headers = require("../../../http/http-headers.js");
 var import_http_query = require("../../../http/http-query.js");
 var import_injector = require("../../../injector/index.js");
 var import_logger = require("../../../logger/index.js");
-var import_cancellation_token = require("../../../utils/cancellation-token.js");
 var import_encoding = require("../../../utils/encoding.js");
 var import_feedable_async_iterable = require("../../../utils/feedable-async-iterable.js");
 var import_readable_stream_adapter = require("../../../utils/stream/readable-stream-adapter.js");
@@ -129,7 +129,7 @@ let NodeHttpServer = class NodeHttpServer2 extends import_http_server.HttpServer
       }
       if (connections > 0) {
         this.logger.info(`Waiting for ${connections} connections to end`);
-        await (0, import_timing.cancelableTimeout)(250, import_cancellation_token.CancellationToken.from(close$));
+        await (0, import_timing.cancelableTimeout)(250, import_cancellation.CancellationToken.from(close$));
       }
     }
     this.untrackConnectedSockets?.();