@superutils/promise 1.1.6 → 1.2.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _superutils_core from '@superutils/core';
-import { ValueOrPromise, TimeoutId, PositiveNumber, DeferredOptions } from '@superutils/core';
+import { ValueOrPromise, PositiveNumber, DeferredOptions, TimeoutId } from '@superutils/core';
 
 interface IPromisE<T = unknown> extends Promise<T> {
     /** 0: pending, 1: resolved, 2: rejected */
@@ -17,63 +17,6 @@ interface IPromisE<T = unknown> extends Promise<T> {
     /** Indicates if the promise has been resolved */
     readonly resolved: boolean;
 }
-interface IPromisE_Delay<T = unknown> extends Promise<T>, IPromisE<T> {
-    /**
-     * Caution: pausing will prevent the promise from resolving/rejeting automatically.
-     *
-     * In order to finalize the promise either the `resolve()` or the `reject()` method must be invoked manually.
-     *
-     * An never-finalized promise may cause memory leak and will leave it at the mercry of the garbage collector.
-     * Use `pause()` only if you are sure.
-     *
-     * @example
-     * ```typescript
-     * // Example 1: SAFE => no memory leak, because no reference to the promise is stored and no suspended code
-     * <button onClick={() => {
-     *     const promise = PromisE.delay(1000).then(... do stuff ....)
-     *     setTimeout(() => promise.pause(), 300)
-     * }}>Click Me</button>
-     * ```
-     *
-     * @example UNSAFE => potential memory leak, because of suspended code
-     * ```typescript
-     * <button onClick={() => {
-     *     const promise = PromisE.delay(1000)
-     *     setTimeout(() => promise.pause(), 300)
-     *     await promise // suspended code
-     *     //... do stuff ....
-     * }}>Click Me</button>
-     * ```
-     *
-     * @example UNSAFE => potential memory leak, because of preserved reference.
-     * ```typescript
-     * // Until the reference to promises is collected by the garbage collector,
-     * // reference to the unfinished promise will remain in memory.
-     * const promises = []
-     * <button onClick={() => {
-     *     const promise = PromisE.delay(1000)
-     *     setTimeout(() => promise.pause(), 300)
-     *     promises.push(promise)
-     * }}>Click Me</button>
-     * ```
-     */
-    pause: () => void;
-    /** Timeout ID */
-    timeoutId: TimeoutId;
-}
-/**
- * Descibes a timeout PromisE and it's additional properties.
- */
-type IPromisE_Timeout<T = unknown> = IPromisE<T> & {
-    /** Clearing the timeout will prevent it from timing out */
-    clearTimeout: () => void;
-    /** The result/data promise. If more than one supplied in `args` result promise will be a combined `PromisE.all` */
-    data: IPromisE<T>;
-    /** A shorthand getter to check if the promise has timed out. Same as `promise.timeout.rejected`. */
-    readonly timedout: boolean;
-    /** The timeout promise */
-    timeout: IPromisE_Delay<T>;
-};
 type OnEarlyFinalize<T> = <TResolved extends boolean, TValue = TResolved extends true ? T : unknown>(resolved: TResolved, resultOrReason: TValue) => ValueOrPromise<unknown>;
 type PromiseParams<T = unknown> = ConstructorParameters<typeof Promise<T>>;
 
@@ -85,7 +28,7 @@ type DeferredAsyncDefaults<ThisArg = unknown, Delay = unknown> = Pick<Required<D
     delayMs: number;
 };
 /** Options for `PromisE.deferred` and other related functions */
-type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
+type DeferredAsyncOptions<ThisArg = unknown, Delay = number> = {
     /**
      * Delay in milliseconds, used for `debounce` and `throttle` modes. Use `0` for sequential execution.
      *
@@ -93,7 +36,7 @@ type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
      *
      * Default: `100` (or whatever is set in `PromisE.deferred.defaults.delayMs`)
      */
-    delayMs?: 0 | PositiveNumber<Delay>;
+    delayMs?: number | PositiveNumber<Delay>;
     /**
      * Whether to ignore (based on `resolveIgnored` settings) stale promises.
      * In debouce/throttle mode, when an older promise is resolved after a newly resolved promise,
@@ -126,6 +69,8 @@ type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
      */
     resolveError?: ResolveError;
 } & (({
+    delayMs?: PositiveNumber<Delay>;
+} & DeferredOptions<ThisArg>) | ({
     delayMs: 0;
 } & {
     throttle?: false;
@@ -133,9 +78,7 @@ type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
     onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
     /** The value to be used as "thisArg" whenever any of the callbacks are invoked */
     thisArg?: ThisArg;
-}) | ({
-    delayMs?: PositiveNumber<Delay>;
-} & DeferredOptions<ThisArg>));
+}));
 /** Determines what to do when deferred promise/function fails */
 declare enum ResolveError {
     /** Neither resolve nor reject the failed */
@@ -160,6 +103,51 @@ declare enum ResolveIgnored {
     WITH_UNDEFINED = "WITH_UNDEFINED"
 }
 
+interface IPromisE_Delay<T = unknown> extends Promise<T>, IPromisE<T> {
+    /**
+     * Caution: pausing will prevent the promise from resolving/rejeting automatically.
+     *
+     * In order to finalize the promise either the `resolve()` or the `reject()` method must be invoked manually.
+     *
+     * An never-finalized promise may cause memory leak and will leave it at the mercry of the garbage collector.
+     * Use `pause()` only if you are sure.
+     *
+     * @example
+     * ```typescript
+     * // Example 1: SAFE => no memory leak, because no reference to the promise is stored and no suspended code
+     * <button onClick={() => {
+     *     const promise = PromisE.delay(1000).then(... do stuff ....)
+     *     setTimeout(() => promise.pause(), 300)
+     * }}>Click Me</button>
+     * ```
+     *
+     * @example UNSAFE => potential memory leak, because of suspended code
+     * ```typescript
+     * <button onClick={() => {
+     *     const promise = PromisE.delay(1000)
+     *     setTimeout(() => promise.pause(), 300)
+     *     await promise // suspended code
+     *     //... do stuff ....
+     * }}>Click Me</button>
+     * ```
+     *
+     * @example UNSAFE => potential memory leak, because of preserved reference.
+     * ```typescript
+     * // Until the reference to promises is collected by the garbage collector,
+     * // reference to the unfinished promise will remain in memory.
+     * const promises = []
+     * <button onClick={() => {
+     *     const promise = PromisE.delay(1000)
+     *     setTimeout(() => promise.pause(), 300)
+     *     promises.push(promise)
+     * }}>Click Me</button>
+     * ```
+     */
+    pause: () => void;
+    /** Timeout ID */
+    timeoutId: TimeoutId;
+}
+
 /** Function to determine whether retry should be attempted based on previous result/error */
 type RetryIfFunc<T = unknown> = (prevResult: T | undefined, retryCount: number, error?: unknown) => ValueOrPromise<boolean | void>;
 /** Options for automatic retry mechanism */
@@ -273,7 +261,7 @@ declare class PromisEBase<T = unknown> extends Promise<T> implements IPromisE<T>
     /** Sugar for `new PromisE(Promise.race(..))` */
     static race: <T_1 extends unknown[]>(values: T_1) => IPromisE<Awaited<T_1[number]>>;
     /** Extends Promise.reject */
-    static reject: <T_1 = never>(reason: unknown) => IPromisE<T_1>;
+    static reject: <T_1 = never>(reason: unknown) => PromisEBase<T_1>;
     /** Sugar for `new PromisE(Promise.resolve(...))` */
     static resolve: <T_1>(value?: T_1 | PromiseLike<T_1>) => IPromisE<T_1>;
     /** Sugar for `new PromisE(Promise.try(...))` */
@@ -310,25 +298,62 @@ declare class PromisEBase<T = unknown> extends Promise<T> implements IPromisE<T>
     };
 }
 
-type TimeoutFunc<T extends unknown[]> = {
+/**
+ * Descibes a timeout PromisE and it's additional properties.
+ */
+type IPromisE_Timeout<T = unknown> = IPromisE<T> & {
+    readonly aborted: boolean;
+    /**
+     * Removes `abortCtrl/signal` listeners, effectively disabling external cancellation via AbortController.
+     */
+    cancelAbort: () => void;
+    /**
+     * Clears the timeout timer, preventing the promise from being rejected due to a timeout.
+     */
+    clearTimeout: () => void;
+    /** The underlying data promise. If multiple promises were passed to `timeout`, this represents the combined result (defaulting to `PromisE.all`). */
+    data: IPromisE<T>;
+    /** Read-only property indicating if the promise timed out. Equivalent to checking `promise.timeout.rejected`. */
+    readonly timedout: boolean;
+    /** The internal promise that handles the timeout logic. It rejects when the duration expires. */
+    timeout: IPromisE_Delay<T>;
+};
+type TimeoutResult<T extends unknown[], TFunc extends keyof TimeoutFunc<T>, Values extends unknown[] = {
+    -readonly [P in keyof T]: T[P] extends (...args: unknown[]) => infer ReturnType ? ReturnType : T[P];
+}> = Awaited<T['length'] extends 1 ? Values[0] : ReturnType<TimeoutFunc<Values>[TFunc]>>;
+type TimeoutFunc<T extends unknown[] = []> = {
     all: typeof PromisEBase.all<T>;
     allSettled: typeof PromisEBase.allSettled<T>;
     any: typeof PromisEBase.any<T>;
     race: typeof PromisEBase.race<T>;
 };
 /**
- * `PromisE.timeout` options
+ * Options for `PromisE.timeout()`
  *
- * @param func (optional) name of the supported `PromieBase` static method. Default: `"all"`
+ * @param func (optional) name of the supported `PromiEBase` static method to be used to resolve
+ * when more than one promise/function is provided. Default: `"all"`
  * @param timeout (optional) timeout duration in milliseconds. Default: `10_000` (10 seconds)
  * @param timeoutMsg (optional) timeout error message. Default: `"Timed out after 10000ms"`
  *
  */
-type TimeoutOptions<Func extends string = 'all'> = {
-    func: Func;
+type TimeoutOptions<T extends unknown[] = [], Func extends string = 'all'> = {
+    abortCtrl?: AbortController;
+    func?: T['length'] extends 0 ? never : T['length'] extends 1 ? never : Func;
+    /**
+     * Callback invoked when the promise is rejected due to an abort signal.
+     * Optionally, return an `Error` object to reject the promise with a custom error.
+     */
+    onAbort?: () => ValueOrPromise<void | Error>;
+    /**
+     * Callback invoked when the promise times out.
+     * Optionally, return an `Error` object to reject the promise with a custom error.
+     */
+    onTimeout?: () => ValueOrPromise<void | Error>;
+    signal?: AbortSignal;
     timeout?: number;
-    timeoutMsg?: string;
 };
+/** Default options for `PromisE.timeout()` */
+type TimeoutOptionsDefault = Required<Omit<TimeoutOptions<unknown[], keyof TimeoutFunc>, 'abortCtrl' | 'signal'>>;
 
 /**
  * @function PromisE.deferred
@@ -521,7 +546,7 @@ declare function deferredCallback<TDefault = unknown, ThisArg = unknown, Delay =
  * func()
  * ```
  */
-declare function delay<T = number, TReject extends boolean = boolean>(duration?: number, result?: T | (() => T), asRejected?: TReject): IPromisE_Delay<T>;
+declare function delay<T = number, TReject extends boolean = boolean>(duration?: number, result?: T | (() => T | Promise<T>), asRejected?: TReject): IPromisE_Delay<T>;
 declare namespace delay {
     var defaults: {
         /** Default delay duration in milliseconds */
@@ -565,18 +590,22 @@ declare namespace delay {
  */
 declare function delayReject<T = never>(duration: number, reason?: unknown): IPromisE_Delay<T>;
 
+/** Timeout duration (in milliseconds) used as a fallback when positive number is not provided to {@link timeout} */
+declare const FALLBACK_TIMEOUT = 10000;
 /**
  * Creates a new promise that wraps one or more promises and rejects if they do not settle within a
  * specified timeout duration. When multiple promises are provided, they can be processed using methods like
  *  `all` (default), `race`, `any`, or `allSettled`.
  *
  * @param timeout (optional) timeout duration in milliseconds.
- * Default: `10000` (10 seconds)
+ * Default: `10_000` (10 seconds)
  *
  * @param values rest param containing one or more promises/values
  *
- * @example Wokring with a single promise: resolved succesfully
+ * @example Working with a single promise
  * ```typescript
+ * import PromisE from '@supertuils/promise'
+ *
  * PromisE.timeout(
  *   5000, // timeout after 5000ms
  *   PromisE.delay(1000), // resolves after 1000ms with value 1000
@@ -584,8 +613,21 @@ declare function delayReject<T = never>(duration: number, reason?: unknown): IPr
  * // Result: 1000
  * ```
  *
+ * @example Working with a single function
+ * ```typescript
+ * import PromisE from '@supertuils/promise'
+ *
+ * PromisE.timeout(
+ *   5000, // timeout after 5000ms
+ *   () => PromisE.delay(1000), // function resolves after 1000ms with value 1000
+ * ).then(console.log)
+ * // Result: 1000
+ * ```
+ *
  * @example Promise times out & rejected
  * ```typescript
+ * import PromisE from '@supertuils/promise'
+ *
  * PromisE.timeout(
  *     5000, // timeout after 5000ms
  *     PromisE.delay(20000), // resolves after 20000ms with value 20000
@@ -593,13 +635,15 @@ declare function delayReject<T = never>(duration: number, reason?: unknown): IPr
  * // Error: Error('Timed out after 5000ms')
  *```
  *
- * @example Working with multiple promises, resolved using "PromisE.all()"
+ * @example Working with multiple promises/functions, resolved using "PromisE.all()"
  *
  * ```typescript
+ * import PromisE from '@supertuils/promise'
+ *
  * PromisE.timeout(
  *     5000, // timeout after 5000ms
  *     PromisE.delay(1000), // resolves after 1000ms with value 1000
- *     PromisE.delay(2000), // resolves after 2000ms with value 2000
+ *     () => PromisE.delay(2000), // resolves after 2000ms with value 2000
  *     PromisE.delay(3000), // resolves after 3000ms with value 3000
  * ).then(console.log)
  * // Result: [ 1000, 2000, 3000 ]
@@ -608,6 +652,8 @@ declare function delayReject<T = never>(duration: number, reason?: unknown): IPr
  * @example Promise times out & but not rejected.
  * Eg: when API request is taking longer than expected, print a message avoid rejecting the promise.
  * ```typescript
+ * import PromisE from '@supertuils/promise'
+ *
  * const promise = PromisE.timeout(
  *     5000, // timeout after 5000ms
  *     PromisE.delay(20000), // data promise, resolves after 20000ms with value 20000
@@ -622,10 +668,32 @@ declare function delayReject<T = never>(duration: number, reason?: unknown): IPr
  *     return promise.data
  * })
  *```
+ */
+declare function timeout<T extends [unknown, ...unknown[]]>(timeout: number, ...values: T): IPromisE_Timeout<TimeoutResult<T, 'all'>>;
+/**
+ *
+ * @param options An options object can be passed with one or more of the following properties:
+ * @param options.abortCtrl (optional) AbortController to manually reject promise externally and/or to sync abort with timeout rejection
+ * @param options.abortMsg (optional) error message when promise is rejected by abort controller/signal
+ * @param options.func (optional) Name of the `PromisE` static method to be used to combine the `values`.
+ * Only used when more than one promise is provided. Default: `"all"`
+ *
+ * Accepted values:
+ * 1. `'all'` **(default)**: for `PromisE.all`
+ * 2. `'allSettled'`: for `PromisE.allSettled`
+ * 3. `'any'`: for `PromisE.any`
+ * 4. `'race'`: for `PromisE.race`
+ * @param options.signal (optional) AbortSignal to manually reject promise externally
+ * @param options.timeout (optional) timeout duration in milliseconds. If positive number is not provided, the default value will be used. Default: `10_000` (10 seconds)
+ * @param options.timeoutMsg (optional) custom error message to be used when promises timeout.
+ *
+ * @param values Mix of promises, values and/or functions
  *
- * @example Multiple promises resolved using "PromisE.race()"
+ * @example Working with multiple promises/functions resolved using "PromisE.race()"
  *
  * ```typescript
+ * import PromisE from '@supertuils/promise'
+ *
  * PromisE.timeout(
  *     { // instead of `timeout: number` an object can be used for additional options
  *         func: 'race', // tells PromisE.timeout to use `PromisE.race(promises)`
@@ -633,35 +701,15 @@ declare function delayReject<T = never>(duration: number, reason?: unknown): IPr
  *         timeoutMsg: 'My custom timed out message',
  *     },
  *     PromisE.delay(1000), // resolves after 1000ms with value 1000
- *     PromisE.delay(2000), // resolves after 2000ms with value 2000
+ *     () => PromisE.delay(2000), // resolves after 2000ms with value 2000
  *     PromisE.delay(3000), // resolves after 3000ms with value 3000
  * ).then(console.log)
  * // Result: 1000 (Result of `Promise.race(promises)`)
  * ```
  */
-declare function timeout<T extends [unknown, ...unknown[]], // require at least one value
-Result = T['length'] extends 1 ? Awaited<T[0]> : Awaited<T[number]>[]>(timeout: number, ...values: T): IPromisE_Timeout<Result>;
-/**
- *
- * @param options An options object can be passed with one or more of the following properties:
- * @param options.func (optional) Name of the `PromisE` method to be used to combine the `values`.
- * Only used when more than one promise is provided.
- *
- * Accepted values:
- * 1. `'all'` **(default)**: for `PromisE.all`
- * 2. `'allSettled'`: for `PromisE.allSettled`
- * 3. `'any'`: for `PromisE.any`
- * 4. `'race'`: for `PromisE.race`
- *
- * @param options.timeout (optional) timeout duration in milliseconds. Default: `10_000` (10 seconds)
- * @param options.timeoutMsg (optional) custom error message to be used when promises timeout.
- *
- * @param values
- */
-declare function timeout<T extends [unknown, ...unknown[]], // require at least one value
-TFunc extends keyof TimeoutFunc<T>, Result = T['length'] extends 1 ? Awaited<T[0]> : Awaited<ReturnType<TimeoutFunc<T>[TFunc]>>>(options: TimeoutOptions<TFunc>, ...values: T): IPromisE_Timeout<Result>;
+declare function timeout<T extends unknown[], TFunc extends keyof TimeoutFunc<T> = keyof TimeoutFunc<T>>(options: TimeoutOptions<T, TFunc>, ...values: T): IPromisE_Timeout<TimeoutResult<T, TFunc>>;
 declare namespace timeout {
-    var defaultOptions: Required<TimeoutOptions>;
+    var defaults: Required<Omit<TimeoutOptions<unknown[], keyof TimeoutFunc<[]>>, "abortCtrl" | "signal">>;
 }
 
 /**
@@ -792,4 +840,4 @@ declare const retry: {
     };
 };
 
-export { type DeferredAsyncCallback, type DeferredAsyncDefaults, type DeferredAsyncOptions, type GetPromiseFunc, type IPromisE, type IPromisE_Delay, type IPromisE_Timeout, type OnEarlyFinalize, PromisE, PromisEBase, type PromiseParams, ResolveError, ResolveIgnored, type RetryIfFunc, type RetryOptions, type TimeoutFunc, type TimeoutOptions, PromisE as default, deferred, deferredCallback, delay, delayReject, retry, timeout };
+export { type DeferredAsyncCallback, type DeferredAsyncDefaults, type DeferredAsyncOptions, FALLBACK_TIMEOUT, type GetPromiseFunc, type IPromisE, type IPromisE_Delay, type IPromisE_Timeout, type OnEarlyFinalize, PromisE, PromisEBase, type PromiseParams, ResolveError, ResolveIgnored, type RetryIfFunc, type RetryOptions, type TimeoutFunc, type TimeoutOptions, type TimeoutOptionsDefault, type TimeoutResult, PromisE as default, deferred, deferredCallback, delay, delayReject, retry, timeout };

package/dist/index.js

@@ -87,11 +87,6 @@ var _PromisEBase = class _PromisEBase extends Promise {
   get state() {
     return this._state;
   }
-  // static withResolvers = <T = unknown>() => {
-  // 	const pwr = globalThis.Promise.withResolvers<T>()
-  // 	const promise = new PromisEBase<T>(pwr.promise) as IPromisE<T>
-  // 	return { ...pwr, promise }
-  // }
 };
 //
 //
@@ -108,8 +103,8 @@ _PromisEBase.any = (values) => new _PromisEBase(globalThis.Promise.any(values));
 _PromisEBase.race = (values) => new _PromisEBase(globalThis.Promise.race(values));
 /** Extends Promise.reject */
 _PromisEBase.reject = (reason) => {
-  const { promise, reject } = _PromisEBase.withResolvers();
-  queueMicrotask(() => reject(reason));
+  const promise = new _PromisEBase();
+  queueMicrotask(() => promise.reject(reason));
   return promise;
 };
 /** Sugar for `new PromisE(Promise.resolve(...))` */
@@ -312,23 +307,28 @@ var deferredCallback_default = deferredCallback;
 
 // src/delay.ts
 import { fallbackIfFails as fallbackIfFails3, isFn as isFn3 } from "@superutils/core";
-function delay(duration = delay.defaults.duration, result = duration, asRejected = false) {
+function delay(duration = delay.defaults.duration, result, asRejected = false) {
   const promise = new PromisEBase_default();
   const finalize = (result2) => {
-    var _a;
-    if (isFn3(result2))
-      result2 = (_a = fallbackIfFails3(result2, [], void 0)) != null ? _a : duration;
-    if (!asRejected) return promise.resolve(result2);
-    promise.reject(
-      duration !== result2 && result2 !== void 0 ? result2 : new Error(
-        `${delay.defaults.delayTimeoutMsg} ${duration}ms`
-      )
+    const _result = fallbackIfFails3(
+      async () => {
+        const _result2 = await (isFn3(result2) ? result2() : result2);
+        return !asRejected ? _result2 != null ? _result2 : duration : _result2 != null ? _result2 : new Error(
+          `${delay.defaults.delayTimeoutMsg} ${duration}ms`
+        );
+      },
+      [],
+      // when result is a function and it fails/rejects,
+      // promise will reject even if `asRejected = false`
+      (err) => Promise.reject(err)
     );
+    !asRejected ? promise.resolve(_result) : _result.then(promise.reject, promise.reject);
   };
   promise.timeoutId = setTimeout(() => finalize(result), duration);
   promise.pause = () => clearTimeout(promise.timeoutId);
   promise.catch(() => {
   }).finally(() => promise.pause());
+  promise.onEarlyFinalize.push(() => promise.pause());
   return promise;
 }
 delay.defaults = {
@@ -412,44 +412,116 @@ retry.defaults = {
 var retry_default = retry;
 
 // src/timeout.ts
-import { isFn as isFn4, isObj, isPositiveNumber as isPositiveNumber2 } from "@superutils/core";
-function timeout(timeout2, ...values) {
-  var _a, _b;
-  let funcName = "all";
-  let timeoutMsg = "";
-  if (isObj(timeout2)) {
-    funcName = timeout2.func;
-    timeoutMsg = (_a = timeout2.timeoutMsg) != null ? _a : "";
-    timeout2 = (_b = timeout2.timeout) != null ? _b : 1e4;
-  }
-  timeout2 = isPositiveNumber2(timeout2) && timeout2 || 1e4;
-  const func = isFn4(PromisEBase_default[funcName]) ? PromisEBase_default[funcName] : PromisEBase_default.all;
-  const dataPromise = values.length <= 1 ? new PromisEBase_default(values == null ? void 0 : values[0]) : func(values);
-  const timeoutPromise = delayReject_default(
-    timeout2,
-    new Error(timeoutMsg || `Timed out after ${timeout2}ms`)
+import {
+  arrUnique,
+  fallbackIfFails as fallbackIfFails5,
+  isFn as isFn4,
+  isObj,
+  isPositiveNumber as isPositiveNumber2,
+  noop,
+  objCopy as objCopy3
+} from "@superutils/core";
+var FALLBACK_TIMEOUT = 1e4;
+function timeout(timeoutOrOptions, ...values) {
+  const options = objCopy3(
+    timeout.defaults,
+    isObj(timeoutOrOptions) ? timeoutOrOptions : { timeout: timeoutOrOptions },
+    [],
+    "empty"
+  );
+  const { func, onTimeout } = options;
+  const duration = isPositiveNumber2(options.timeout) ? options.timeout : FALLBACK_TIMEOUT;
+  const arrPromises = values.map((v) => isFn4(v) ? PromisEBase_default.try(v) : v);
+  const dataPromise = arrPromises.length <= 1 ? (
+    // single promise resolves to a single result
+    arrPromises[0] instanceof PromisEBase_default ? arrPromises[0] : new PromisEBase_default(arrPromises[0])
+  ) : (
+    // multiple promises resolve to an array of results
+    (isFn4(PromisEBase_default[func]) ? PromisEBase_default[func] : PromisEBase_default.all)(
+      arrPromises
+    )
   );
+  const timeoutPromise = delayReject_default(duration, onTimeout);
   const promise = PromisEBase_default.race([
     dataPromise,
     timeoutPromise
   ]);
-  promise.clearTimeout = () => clearTimeout(timeoutPromise.timeoutId);
-  promise.data = dataPromise;
-  promise.timeout = timeoutPromise;
-  Object.defineProperty(promise, "timedout", {
-    get: () => promise.timeout.rejected
-  });
-  dataPromise.catch(() => {
-  }).finally(() => {
-    promise.clearTimeout();
-  });
+  addPropsNListeners(promise, dataPromise, timeoutPromise, options);
   return promise;
 }
-timeout.defaultOptions = {
+timeout.defaults = {
   func: "all",
-  timeout: 1e4
+  timeout: FALLBACK_TIMEOUT
 };
 var timeout_default = timeout;
+var addPropsNListeners = (promise, dataPromise, timeoutPromise, options) => {
+  const { abortCtrl, onAbort, signal } = options;
+  const signals = arrUnique([abortCtrl == null ? void 0 : abortCtrl.signal, signal].filter(Boolean));
+  Object.defineProperties(promise, {
+    aborted: {
+      get() {
+        return promise.rejected && !!signals.find((s) => s.aborted);
+      }
+    },
+    cancelAbort: {
+      get() {
+        return () => {
+          signals == null ? void 0 : signals.forEach(
+            (signal2) => signal2.removeEventListener("abort", handleAbort)
+          );
+        };
+      }
+    },
+    clearTimeout: {
+      get() {
+        return () => clearTimeout(timeoutPromise.timeoutId);
+      }
+    },
+    data: {
+      get() {
+        return dataPromise;
+      }
+    },
+    timeout: {
+      get() {
+        return timeoutPromise;
+      }
+    },
+    timedout: {
+      get() {
+        return promise.rejected && timeoutPromise.rejected;
+      }
+    }
+  });
+  const cleanup = () => {
+    promise.cancelAbort();
+    promise.clearTimeout();
+  };
+  promise.onEarlyFinalize.push(cleanup);
+  promise.catch(() => {
+    var _a;
+    if (!timeoutPromise.rejected && !signals.find((x) => x.aborted))
+      return;
+    ((_a = abortCtrl == null ? void 0 : abortCtrl.signal) == null ? void 0 : _a.aborted) === false && abortCtrl.abort();
+  }).finally(cleanup);
+  if (!signals.length) return;
+  const started = /* @__PURE__ */ new Date();
+  function handleAbort() {
+    if (!promise.pending) return;
+    fallbackIfFails5(async () => await (onAbort == null ? void 0 : onAbort()), [], void 0).then(
+      (err) => {
+        var _a;
+        err != null ? err : err = new Error(
+          `Aborted after ${(/* @__PURE__ */ new Date()).getTime() - started.getTime()}ms`
+        );
+        (_a = err.name) != null ? _a : err.name = "AbortError";
+        promise.reject(err);
+      },
+      noop
+    );
+  }
+  signals.forEach((signal2) => signal2.addEventListener("abort", handleAbort));
+};
 
 // src/PromisE.ts
 var PromisE = class extends PromisEBase_default {
@@ -465,6 +537,7 @@ var PromisE_default = PromisE;
 // src/index.ts
 var index_default = PromisE_default;
 export {
+  FALLBACK_TIMEOUT,
   PromisE,
   PromisEBase,
   ResolveError,

package/package.json

@@ -4,7 +4,7 @@
 		"url": "https://github.com/alien45/superutils/issues"
 	},
 	"dependencies": {
-		"@superutils/core": "^1.1.6"
+		"@superutils/core": "^1.1.8"
 	},
 	"description": "An extended Promise with additional features such as status tracking, deferred/throttled execution, timeout and retry mechanism.",
 	"files": [
@@ -23,7 +23,7 @@
 	"main": "dist/index.js",
 	"name": "@superutils/promise",
 	"peerDpendencies": {
-		"@superutils/core": "^1.1.6"
+		"@superutils/core": "^1.2.0"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -43,5 +43,5 @@
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.1.6"
+	"version": "1.2.0"
 }