@naturalcycles/js-lib 15.72.1 → 15.73.0

package/dist/abort.d.ts

@@ -1,3 +1,4 @@
+import type { NumberOfMilliseconds } from './types.js';
 /**
  * Like AbortSignal, but it can "abort itself" via the `.abort()` method.
  *
@@ -22,3 +23,32 @@ export interface AbortableSignal extends AbortSignal {
  * @experimental
  */
 export declare function createAbortableSignal(): AbortableSignal;
+/**
+ * Returns AbortSignal if ms is defined.
+ * Otherwise returns undefined.
+ */
+export declare function abortSignalTimeoutOrUndefined(ms: NumberOfMilliseconds | undefined): AbortSignal | undefined;
+/**
+ * Returns an AbortSignal that aborts after the given number of milliseconds.
+ * Uses native `AbortSignal.timeout()` when available, falls back to a polyfill.
+ *
+ * The abort reason is a DOMException with name "TimeoutError".
+ */
+export declare function abortSignalTimeout(ms: NumberOfMilliseconds): AbortSignal;
+export declare function polyfilledAbortSignalTimeout(ms: NumberOfMilliseconds): AbortSignal;
+/**
+ * Returns AbortSignal.any(signals) is the array (after filtering undefined inputs) is not empty,
+ * otherwise undefined.
+ */
+export declare function abortSignalAnyOrUndefined(signals: (AbortSignal | undefined)[]): AbortSignal | undefined;
+/**
+ * Returns an AbortSignal that aborts when any of the given signals abort.
+ * Uses native `AbortSignal.any()` when available, falls back to a polyfill.
+ *
+ * The abort reason is taken from the first signal that aborts.
+ * If any input signal is already aborted, the returned signal is immediately aborted.
+ *
+ * If only 1 signal is passed in the input array - that Signal is returned as-is.
+ */
+export declare function abortSignalAny(signals: AbortSignal[]): AbortSignal;
+export declare function polyfilledAbortSignalAny(signals: AbortSignal[]): AbortSignal;

package/dist/abort.js

@@ -1,3 +1,4 @@
+import { _isTruthy } from './is.util.js';
 /**
  * Creates AbortableSignal,
  * which is like AbortSignal, but can "abort itself" with `.abort()` method.
@@ -10,3 +11,69 @@ export function createAbortableSignal() {
         abort: ac.abort.bind(ac),
     });
 }
+/**
+ * Returns AbortSignal if ms is defined.
+ * Otherwise returns undefined.
+ */
+export function abortSignalTimeoutOrUndefined(ms) {
+    return ms ? abortSignalTimeout(ms) : undefined;
+}
+/**
+ * Returns an AbortSignal that aborts after the given number of milliseconds.
+ * Uses native `AbortSignal.timeout()` when available, falls back to a polyfill.
+ *
+ * The abort reason is a DOMException with name "TimeoutError".
+ */
+export function abortSignalTimeout(ms) {
+    return typeof AbortSignal.timeout === 'function'
+        ? AbortSignal.timeout(ms)
+        : polyfilledAbortSignalTimeout(ms);
+}
+export function polyfilledAbortSignalTimeout(ms) {
+    const ac = new AbortController();
+    setTimeout(() => {
+        ac.abort(new DOMException('The operation was aborted due to timeout', 'TimeoutError'));
+    }, ms);
+    return ac.signal;
+}
+/**
+ * Returns AbortSignal.any(signals) is the array (after filtering undefined inputs) is not empty,
+ * otherwise undefined.
+ */
+export function abortSignalAnyOrUndefined(signals) {
+    const filtered = signals.filter(_isTruthy);
+    return filtered.length ? abortSignalAny(filtered) : undefined;
+}
+/**
+ * Returns an AbortSignal that aborts when any of the given signals abort.
+ * Uses native `AbortSignal.any()` when available, falls back to a polyfill.
+ *
+ * The abort reason is taken from the first signal that aborts.
+ * If any input signal is already aborted, the returned signal is immediately aborted.
+ *
+ * If only 1 signal is passed in the input array - that Signal is returned as-is.
+ */
+export function abortSignalAny(signals) {
+    if (signals.length === 1) {
+        return signals[0];
+    }
+    return typeof AbortSignal.any === 'function'
+        ? AbortSignal.any(signals)
+        : polyfilledAbortSignalAny(signals);
+}
+export function polyfilledAbortSignalAny(signals) {
+    const ac = new AbortController();
+    for (const signal of signals) {
+        if (signal.aborted) {
+            ac.abort(signal.reason);
+            return ac.signal;
+        }
+    }
+    for (const signal of signals) {
+        signal.addEventListener('abort', () => ac.abort(signal.reason), {
+            once: true,
+            signal: ac.signal,
+        });
+    }
+    return ac.signal;
+}

package/dist/http/fetcher.d.ts

@@ -16,7 +16,7 @@ export declare class Fetcher {
      *
      * Version is to be incremented every time a difference in behaviour (or a bugfix) is done.
      */
-    static readonly VERSION = 3;
+    static readonly VERSION = 4;
     /**
      * userAgent is statically exposed as Fetcher.userAgent.
      * It can be modified globally, and will be used (read) at the start of every request.

package/dist/http/fetcher.js

@@ -1,10 +1,11 @@
 /// <reference lib="es2023" preserve="true" />
 /// <reference lib="dom" preserve="true" />
 /// <reference lib="dom.iterable" preserve="true" />
+import { abortSignalAnyOrUndefined, abortSignalTimeoutOrUndefined } from '../abort.js';
 import { _ms, _since } from '../datetime/time.util.js';
 import { isServerSide } from '../env.js';
 import { _assertErrorClassOrRethrow, _assertIsError } from '../error/assert.js';
-import { _anyToError, _anyToErrorObject, _errorDataAppend, _errorLikeToErrorObject, HttpRequestError, TimeoutError, UnexpectedPassError, } from '../error/error.util.js';
+import { _anyToError, _anyToErrorObject, _errorDataAppend, _errorLikeToErrorObject, HttpRequestError, UnexpectedPassError, } from '../error/error.util.js';
 import { _clamp } from '../number/number.util.js';
 import { _filterFalsyValues, _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util.js';
 import { pDelay } from '../promise/pDelay.js';
@@ -24,7 +25,7 @@ export class Fetcher {
      *
      * Version is to be incremented every time a difference in behaviour (or a bugfix) is done.
      */
-    static VERSION = 3;
+    static VERSION = 4;
     /**
      * userAgent is statically exposed as Fetcher.userAgent.
      * It can be modified globally, and will be used (read) at the start of every request.
@@ -232,7 +233,8 @@ export class Fetcher {
     async doFetch(opt) {
         const req = this.normalizeOptions(opt);
         const { logger } = this.cfg;
-        const { timeoutSeconds, init: { method }, } = req;
+        const { init: { method }, } = req;
+        const timeoutMillis = req.timeoutSeconds ? req.timeoutSeconds * 1000 : undefined;
         for (const hook of this.cfg.hooks.beforeRequest || []) {
             await hook(req);
         }
@@ -251,21 +253,10 @@ export class Fetcher {
         };
         while (!res.retryStatus.retryStopped) {
             req.started = Date.now();
-            // setup timeout
-            let timeoutId;
-            if (timeoutSeconds) {
-                // Used for Request timeout (when timeoutSeconds is set),
-                // but also for "downloadBody" timeout (even after request returned with 200, but before we loaded the body)
-                // UPD: no, not using for "downloadBody" currently
-                const abortController = new AbortController();
-                req.init.signal = abortController.signal;
-                timeoutId = setTimeout(() => {
-                    // console.log(`actual request timed out in ${_since(req.started)}`)
-                    // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
-                    // so, we're wrapping it in a TimeoutError instance
-                    abortController.abort(new TimeoutError(`request timed out after ${timeoutSeconds} sec`));
-                }, timeoutSeconds * 1000);
-            }
+            req.init.signal = abortSignalAnyOrUndefined([
+                abortSignalTimeoutOrUndefined(timeoutMillis),
+                opt.signal,
+            ]);
             if (req.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -284,22 +275,19 @@ export class Fetcher {
             catch (err) {
                 // For example, CORS error would result in "TypeError: failed to fetch" here
                 // or, `fetch failed` with the cause of `unexpected redirect`
+                // AbortSignal.timeout() throws a DOMException with name "TimeoutError"
                 res.err = _anyToError(err);
                 res.ok = false;
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.fetchResponse = undefined;
             }
-            finally {
-                clearTimeout(timeoutId);
-                // Separate Timeout will be introduced to "download and parse the body"
-            }
             res.statusFamily = this.getStatusFamily(res);
             res.statusCode = res.fetchResponse?.status;
             if (res.fetchResponse?.ok || !req.throwHttpErrors) {
                 try {
                     // We are applying a separate Timeout (as long as original Timeout for now) to "download and parse the body"
                     await pTimeout(async () => await this.onOkResponse(res), {
-                        timeout: timeoutSeconds * 1000 || Number.POSITIVE_INFINITY,
+                        timeout: timeoutMillis || Number.POSITIVE_INFINITY,
                         name: 'Fetcher.downloadBody',
                     });
                 }

package/dist/http/fetcher.model.d.ts

@@ -169,6 +169,12 @@ export interface FetcherOptions {
      * so both should finish within this single timeout (not each).
      */
     timeoutSeconds?: number;
+    /**
+     * AbortSignal to allow the caller to abort the request.
+     * If `timeoutSeconds` is also set, the signals are combined via `AbortSignal.any()`,
+     * so the request aborts on whichever fires first.
+     */
+    signal?: AbortSignal;
     /**
      * Supports all the types that RequestInit.body supports.
      *

package/dist/promise/index.d.ts

@@ -1,4 +1,3 @@
-export * from './abortable.js';
 export * from './pDefer.js';
 export * from './pDelay.js';
 export * from './pFilter.js';

package/dist/promise/index.js

@@ -1,4 +1,3 @@
-export * from './abortable.js';
 export * from './pDefer.js';
 export * from './pDelay.js';
 export * from './pFilter.js';

package/dist/promise/pRetry.d.ts

@@ -1,6 +1,6 @@
 import type { ErrorData } from '../error/error.model.js';
 import type { CommonLogger } from '../log/commonLogger.js';
-import type { AnyFunction } from '../types.js';
+import type { AnyAsyncFunction } from '../types.js';
 export interface PRetryOptions {
     /**
      * If set - will be included in the error message.
@@ -79,5 +79,5 @@ export interface PRetryOptions {
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
-export declare function pRetryFn<T extends AnyFunction>(fn: T, opt?: PRetryOptions): T;
+export declare function pRetryFn<T extends AnyAsyncFunction>(fn: T, opt?: PRetryOptions): T;
 export declare function pRetry<T>(fn: (attempt: number) => Promise<T>, opt?: PRetryOptions): Promise<T>;

package/dist/promise/pTimeout.d.ts

@@ -46,4 +46,4 @@ export declare function pTimeoutFn<T extends AnyAsyncFunction>(fn: T, opt: PTime
  * Throws an Error if the Function is not resolved in a certain time.
  * If the Function rejects - passes this rejection further.
  */
-export declare function pTimeout<T>(fn: AnyAsyncFunction<T>, opt: PTimeoutOptions): Promise<T>;
+export declare function pTimeout<T>(fn: (signal: AbortSignal) => Promise<T>, opt: PTimeoutOptions): Promise<T>;

package/dist/promise/pTimeout.js

@@ -23,9 +23,11 @@ export function pTimeoutFn(fn, opt) {
  * If the Function rejects - passes this rejection further.
  */
 export async function pTimeout(fn, opt) {
+    const ac = new AbortController();
+    const { signal } = ac;
     if (!opt.timeout) {
         // short-circuit to direct execution if 0 timeout is passed
-        return await fn();
+        return await fn(signal);
     }
     const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt;
     const fakeError = opt.fakeError || new Error('TimeoutError');
@@ -46,13 +48,15 @@ export async function pTimeout(fn, opt) {
                     // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                     reject(_errorDataAppend(err, opt.errorData));
                 }
+                ac.abort(err);
                 return;
             }
             reject(err);
+            ac.abort(err);
         }, timeout);
         // Execute the Function
         try {
-            resolve(await fn());
+            resolve(await fn(signal));
         }
         catch (err) {
             reject(err);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.72.1",
+  "version": "15.73.0",
   "dependencies": {
     "tslib": "^2"
   },

package/src/abort.ts

@@ -1,3 +1,6 @@
+import { _isTruthy } from './is.util.js'
+import type { NumberOfMilliseconds } from './types.js'
+
 /**
  * Like AbortSignal, but it can "abort itself" via the `.abort()` method.
  *
@@ -28,3 +31,83 @@ export function createAbortableSignal(): AbortableSignal {
     abort: ac.abort.bind(ac),
   })
 }
+
+/**
+ * Returns AbortSignal if ms is defined.
+ * Otherwise returns undefined.
+ */
+export function abortSignalTimeoutOrUndefined(
+  ms: NumberOfMilliseconds | undefined,
+): AbortSignal | undefined {
+  return ms ? abortSignalTimeout(ms) : undefined
+}
+
+/**
+ * Returns an AbortSignal that aborts after the given number of milliseconds.
+ * Uses native `AbortSignal.timeout()` when available, falls back to a polyfill.
+ *
+ * The abort reason is a DOMException with name "TimeoutError".
+ */
+export function abortSignalTimeout(ms: NumberOfMilliseconds): AbortSignal {
+  return typeof AbortSignal.timeout === 'function'
+    ? AbortSignal.timeout(ms)
+    : polyfilledAbortSignalTimeout(ms)
+}
+
+export function polyfilledAbortSignalTimeout(ms: NumberOfMilliseconds): AbortSignal {
+  const ac = new AbortController()
+  setTimeout(() => {
+    ac.abort(new DOMException('The operation was aborted due to timeout', 'TimeoutError'))
+  }, ms)
+  return ac.signal
+}
+
+/**
+ * Returns AbortSignal.any(signals) is the array (after filtering undefined inputs) is not empty,
+ * otherwise undefined.
+ */
+export function abortSignalAnyOrUndefined(
+  signals: (AbortSignal | undefined)[],
+): AbortSignal | undefined {
+  const filtered = signals.filter(_isTruthy)
+  return filtered.length ? abortSignalAny(filtered) : undefined
+}
+
+/**
+ * Returns an AbortSignal that aborts when any of the given signals abort.
+ * Uses native `AbortSignal.any()` when available, falls back to a polyfill.
+ *
+ * The abort reason is taken from the first signal that aborts.
+ * If any input signal is already aborted, the returned signal is immediately aborted.
+ *
+ * If only 1 signal is passed in the input array - that Signal is returned as-is.
+ */
+export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
+  if (signals.length === 1) {
+    return signals[0]!
+  }
+
+  return typeof AbortSignal.any === 'function'
+    ? AbortSignal.any(signals)
+    : polyfilledAbortSignalAny(signals)
+}
+
+export function polyfilledAbortSignalAny(signals: AbortSignal[]): AbortSignal {
+  const ac = new AbortController()
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      ac.abort(signal.reason)
+      return ac.signal
+    }
+  }
+
+  for (const signal of signals) {
+    signal.addEventListener('abort', () => ac.abort(signal.reason), {
+      once: true,
+      signal: ac.signal,
+    })
+  }
+
+  return ac.signal
+}

package/src/http/fetcher.model.ts

@@ -221,6 +221,13 @@ export interface FetcherOptions {
    */
   timeoutSeconds?: number
 
+  /**
+   * AbortSignal to allow the caller to abort the request.
+   * If `timeoutSeconds` is also set, the signals are combined via `AbortSignal.any()`,
+   * so the request aborts on whichever fires first.
+   */
+  signal?: AbortSignal
+
   /**
    * Supports all the types that RequestInit.body supports.
    *

package/src/http/fetcher.ts

@@ -3,6 +3,7 @@
 /// <reference lib="dom.iterable" preserve="true" />
 
 import type { ReadableStream as WebReadableStream } from 'node:stream/web'
+import { abortSignalAnyOrUndefined, abortSignalTimeoutOrUndefined } from '../abort.js'
 import { _ms, _since } from '../datetime/time.util.js'
 import { isServerSide } from '../env.js'
 import { _assertErrorClassOrRethrow, _assertIsError } from '../error/assert.js'
@@ -13,7 +14,6 @@ import {
   _errorDataAppend,
   _errorLikeToErrorObject,
   HttpRequestError,
-  TimeoutError,
   UnexpectedPassError,
 } from '../error/error.util.js'
 import { _clamp } from '../number/number.util.js'
@@ -68,7 +68,7 @@ export class Fetcher {
    *
    * Version is to be incremented every time a difference in behaviour (or a bugfix) is done.
    */
-  static readonly VERSION = 3
+  static readonly VERSION = 4
   /**
    * userAgent is statically exposed as Fetcher.userAgent.
    * It can be modified globally, and will be used (read) at the start of every request.
@@ -306,9 +306,9 @@ export class Fetcher {
     const req = this.normalizeOptions(opt)
     const { logger } = this.cfg
     const {
-      timeoutSeconds,
       init: { method },
     } = req
+    const timeoutMillis = req.timeoutSeconds ? req.timeoutSeconds * 1000 : undefined
 
     for (const hook of this.cfg.hooks.beforeRequest || []) {
       await hook(req)
@@ -332,21 +332,10 @@ export class Fetcher {
     while (!res.retryStatus.retryStopped) {
       req.started = Date.now() as UnixTimestampMillis
 
-      // setup timeout
-      let timeoutId: number | undefined
-      if (timeoutSeconds) {
-        // Used for Request timeout (when timeoutSeconds is set),
-        // but also for "downloadBody" timeout (even after request returned with 200, but before we loaded the body)
-        // UPD: no, not using for "downloadBody" currently
-        const abortController = new AbortController()
-        req.init.signal = abortController.signal
-        timeoutId = setTimeout(() => {
-          // console.log(`actual request timed out in ${_since(req.started)}`)
-          // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
-          // so, we're wrapping it in a TimeoutError instance
-          abortController.abort(new TimeoutError(`request timed out after ${timeoutSeconds} sec`))
-        }, timeoutSeconds * 1000) as any as number
-      }
+      req.init.signal = abortSignalAnyOrUndefined([
+        abortSignalTimeoutOrUndefined(timeoutMillis),
+        opt.signal,
+      ])
 
       if (req.logRequest) {
         const { retryAttempt } = res.retryStatus
@@ -372,13 +361,11 @@ export class Fetcher {
       } catch (err) {
         // For example, CORS error would result in "TypeError: failed to fetch" here
         // or, `fetch failed` with the cause of `unexpected redirect`
+        // AbortSignal.timeout() throws a DOMException with name "TimeoutError"
         res.err = _anyToError(err)
         res.ok = false
         // important to set it to undefined, otherwise it can keep the previous value (from previous try)
         res.fetchResponse = undefined
-      } finally {
-        clearTimeout(timeoutId)
-        // Separate Timeout will be introduced to "download and parse the body"
       }
       res.statusFamily = this.getStatusFamily(res)
       res.statusCode = res.fetchResponse?.status
@@ -390,7 +377,7 @@ export class Fetcher {
             async () =>
               await this.onOkResponse(res as FetcherResponse<T> & { fetchResponse: Response }),
             {
-              timeout: timeoutSeconds * 1000 || Number.POSITIVE_INFINITY,
+              timeout: timeoutMillis || Number.POSITIVE_INFINITY,
               name: 'Fetcher.downloadBody',
             },
           )

package/src/promise/index.ts

@@ -1,4 +1,3 @@
-export * from './abortable.js'
 export * from './pDefer.js'
 export * from './pDelay.js'
 export * from './pFilter.js'

package/src/promise/pRetry.ts

@@ -2,7 +2,7 @@ import { _since } from '../datetime/time.util.js'
 import type { ErrorData } from '../error/error.model.js'
 import { _errorDataAppend } from '../error/error.util.js'
 import type { CommonLogger } from '../log/commonLogger.js'
-import type { AnyFunction, UnixTimestampMillis } from '../types.js'
+import type { AnyAsyncFunction, UnixTimestampMillis } from '../types.js'
 import { pDelay } from './pDelay.js'
 import { pTimeout } from './pTimeout.js'
 
@@ -98,7 +98,7 @@ export interface PRetryOptions {
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
-export function pRetryFn<T extends AnyFunction>(fn: T, opt: PRetryOptions = {}): T {
+export function pRetryFn<T extends AnyAsyncFunction>(fn: T, opt: PRetryOptions = {}): T {
   return async function pRetryFunction(this: any, ...args: any[]) {
     return await pRetry(() => fn.call(this, ...args), opt)
   } as any

package/src/promise/pTimeout.ts

@@ -64,10 +64,16 @@ export function pTimeoutFn<T extends AnyAsyncFunction>(fn: T, opt: PTimeoutOptio
  * Throws an Error if the Function is not resolved in a certain time.
  * If the Function rejects - passes this rejection further.
  */
-export async function pTimeout<T>(fn: AnyAsyncFunction<T>, opt: PTimeoutOptions): Promise<T> {
+export async function pTimeout<T>(
+  fn: (signal: AbortSignal) => Promise<T>,
+  opt: PTimeoutOptions,
+): Promise<T> {
+  const ac = new AbortController()
+  const { signal } = ac
+
   if (!opt.timeout) {
     // short-circuit to direct execution if 0 timeout is passed
-    return await fn()
+    return await fn(signal)
   }
 
   const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt
@@ -90,15 +96,17 @@ export async function pTimeout<T>(fn: AnyAsyncFunction<T>, opt: PTimeoutOptions)
           // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
           reject(_errorDataAppend(err, opt.errorData))
         }
+        ac.abort(err)
         return
       }
 
       reject(err)
+      ac.abort(err)
     }, timeout)
 
     // Execute the Function
     try {
-      resolve(await fn())
+      resolve(await fn(signal))
     } catch (err) {
       reject(err as Error)
     } finally {

package/dist/promise/abortable.d.ts

@@ -1,20 +0,0 @@
-import type { AnyFunction } from '../types.js';
-/**
- * Similar to AbortController and AbortSignal.
- * Similar to pDefer and Promise.
- * Similar to Subject and Observable.
- *
- * Minimal interface for something that can be aborted in the future,
- * but not necessary.
- * Allows to listen to `onAbort` event.
- *
- * @experimental
- */
-export declare class Abortable {
-    onAbort?: AnyFunction | undefined;
-    constructor(onAbort?: AnyFunction | undefined);
-    aborted: boolean;
-    abort(): void;
-    clear(): void;
-}
-export declare function abortable(onAbort?: AnyFunction): Abortable;

package/dist/promise/abortable.js

@@ -1,32 +0,0 @@
-/**
- * Similar to AbortController and AbortSignal.
- * Similar to pDefer and Promise.
- * Similar to Subject and Observable.
- *
- * Minimal interface for something that can be aborted in the future,
- * but not necessary.
- * Allows to listen to `onAbort` event.
- *
- * @experimental
- */
-export class Abortable {
-    onAbort;
-    constructor(onAbort) {
-        this.onAbort = onAbort;
-    }
-    aborted = false;
-    abort() {
-        if (this.aborted)
-            return;
-        this.aborted = true;
-        this.onAbort?.();
-        this.onAbort = undefined; // cleanup listener
-    }
-    clear() {
-        this.onAbort = undefined;
-    }
-}
-// convenience function
-export function abortable(onAbort) {
-    return new Abortable(onAbort);
-}

package/src/promise/abortable.ts

@@ -1,34 +0,0 @@
-import type { AnyFunction } from '../types.js'
-
-/**
- * Similar to AbortController and AbortSignal.
- * Similar to pDefer and Promise.
- * Similar to Subject and Observable.
- *
- * Minimal interface for something that can be aborted in the future,
- * but not necessary.
- * Allows to listen to `onAbort` event.
- *
- * @experimental
- */
-export class Abortable {
-  constructor(public onAbort?: AnyFunction) {}
-
-  aborted = false
-
-  abort(): void {
-    if (this.aborted) return
-    this.aborted = true
-    this.onAbort?.()
-    this.onAbort = undefined // cleanup listener
-  }
-
-  clear(): void {
-    this.onAbort = undefined
-  }
-}
-
-// convenience function
-export function abortable(onAbort?: AnyFunction): Abortable {
-  return new Abortable(onAbort)
-}