@superutils/promise 1.2.0 → 1.2.1

package/dist/index.d.ts

@@ -6,6 +6,7 @@ interface IPromisE<T = unknown> extends Promise<T> {
     readonly state: 0 | 1 | 2;
     /** callbacks to be invoked whenever PromisE instance is finalized early using non-static resolve/reject methods */
     onEarlyFinalize: OnEarlyFinalize<T>[];
+    onFinalize: OnFinalize<T>[];
     /** Indicates if the promise is still pending/unfinalized */
     readonly pending: boolean;
     /** Reject pending promise early. */
@@ -18,6 +19,7 @@ interface IPromisE<T = unknown> extends Promise<T> {
     readonly resolved: boolean;
 }
 type OnEarlyFinalize<T> = <TResolved extends boolean, TValue = TResolved extends true ? T : unknown>(resolved: TResolved, resultOrReason: TValue) => ValueOrPromise<unknown>;
+type OnFinalize<T> = (result?: T | PromiseLike<T>, error?: unknown) => ValueOrPromise<void>;
 type PromiseParams<T = unknown> = ConstructorParameters<typeof Promise<T>>;
 
 /** Return type of `PromisE.deferred()` */
@@ -28,7 +30,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 = number> = {
+type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
     /**
      * Delay in milliseconds, used for `debounce` and `throttle` modes. Use `0` for sequential execution.
      *
@@ -36,10 +38,10 @@ type DeferredAsyncOptions<ThisArg = unknown, Delay = number> = {
      *
      * Default: `100` (or whatever is set in `PromisE.deferred.defaults.delayMs`)
      */
-    delayMs?: number | PositiveNumber<Delay>;
+    delayMs?: 0 | 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,
+     * In debounce/throttle mode, when an older promise is resolved after a newly resolved promise,
      * the older one is considered stale.
      *
      * Default: `false`
@@ -68,17 +70,13 @@ type DeferredAsyncOptions<ThisArg = unknown, Delay = number> = {
      * See {@link ResolveError} for available options.
      */
     resolveError?: ResolveError;
-} & (({
-    delayMs?: PositiveNumber<Delay>;
-} & DeferredOptions<ThisArg>) | ({
-    delayMs: 0;
-} & {
+} & (Delay extends 0 ? {
     throttle?: false;
     /** Callback invoked whenever promise/function throws error */
     onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
     /** The value to be used as "thisArg" whenever any of the callbacks are invoked */
     thisArg?: ThisArg;
-}));
+} : DeferredOptions<ThisArg>);
 /** Determines what to do when deferred promise/function fails */
 declare enum ResolveError {
     /** Neither resolve nor reject the failed */
@@ -213,6 +211,7 @@ declare class PromisEBase<T = unknown> extends Promise<T> implements IPromisE<T>
     /**
      * callbacks to be invoked whenever PromisE instance is finalized early using non-static resolve()/reject() methods */
     onEarlyFinalize: OnEarlyFinalize<T>[];
+    onFinalize: OnFinalize<T>[];
     /** Create a PromisE instance as a drop-in replacement for Promise */
     constructor(...args: PromiseParams<T>);
     /** Extend an existing Promise instance to check status or finalize early */
@@ -302,6 +301,8 @@ declare class PromisEBase<T = unknown> extends Promise<T> implements IPromisE<T>
  * Descibes a timeout PromisE and it's additional properties.
  */
 type IPromisE_Timeout<T = unknown> = IPromisE<T> & {
+    readonly abortCtrl?: AbortController;
+    /** Read-only property indicating if the promise rejected because of external abort. */
     readonly aborted: boolean;
     /**
      * Removes `abortCtrl/signal` listeners, effectively disabling external cancellation via AbortController.
@@ -318,10 +319,11 @@ type IPromisE_Timeout<T = unknown> = IPromisE<T> & {
     /** 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[] = {
+type TimeoutResult<T extends unknown[], BatchFunc extends keyof BatchFuncs<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[] = []> = {
+}> = Awaited<T['length'] extends 1 ? Values[0] : ReturnType<BatchFuncs<Values>[BatchFunc]>>;
+/** Suported function names for batch operations */
+type BatchFuncs<T extends unknown[] = []> = {
     all: typeof PromisEBase.all<T>;
     allSettled: typeof PromisEBase.allSettled<T>;
     any: typeof PromisEBase.any<T>;
@@ -333,27 +335,56 @@ type TimeoutFunc<T extends unknown[] = []> = {
  * @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<T extends unknown[] = [], Func extends string = 'all'> = {
+type TimeoutOptions<T extends unknown[] = [], BatchFuncName extends string = 'all'> = {
+    /**
+     * An `AbortController` instance.
+     *
+     * If provided:
+     * - It will be aborted automatically when the timeout occurs.
+     * - If it is aborted externally, the promise will be rejected and the timeout will be cleared.
+     */
     abortCtrl?: AbortController;
-    func?: T['length'] extends 0 ? never : T['length'] extends 1 ? never : Func;
+    /**
+     * Whether to call `abortCtrl.abort()` if the promise is finalized externally
+     * (resolved or rejected before timeout or abort).
+     *
+     * Default: `true`
+     */
+    abortOnEarlyFinalize?: boolean;
+    /**
+     * The name of the `PromisEBase` static method to use for resolving multiple promises/functions.
+     *
+     * Only applicable when more than one promise/function is provided.
+     */
+    batchFunc?: T['length'] extends 0 ? never : T['length'] extends 1 ? never : BatchFuncName;
     /**
      * 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.
+     *
+     * Can be used to transform the abort error by returning a custom `Error` object.
      */
     onAbort?: () => ValueOrPromise<void | Error>;
     /**
      * Callback invoked when the promise times out.
-     * Optionally, return an `Error` object to reject the promise with a custom error.
+     *
+     * Can be used to transform the timeout error by returning a custom `Error` object.
      */
     onTimeout?: () => ValueOrPromise<void | Error>;
+    /**
+     * An `AbortSignal` to listen to.
+     *
+     * If aborted:
+     * - The promise will be rejected.
+     * - The `abortCtrl` (if provided and distinct) will be aborted.
+     * - The timeout will be cleared.
+     */
     signal?: AbortSignal;
+    /** Timeout duration in milliseconds. */
     timeout?: number;
 };
 /** Default options for `PromisE.timeout()` */
-type TimeoutOptionsDefault = Required<Omit<TimeoutOptions<unknown[], keyof TimeoutFunc>, 'abortCtrl' | 'signal'>>;
+type TimeoutOptionsDefault = Required<Omit<TimeoutOptions<unknown[], keyof BatchFuncs>, 'abortCtrl' | 'signal'>>;
 
 /**
  * @function PromisE.deferred
@@ -590,8 +621,6 @@ 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
@@ -674,7 +703,6 @@ declare function timeout<T extends [unknown, ...unknown[]]>(timeout: number, ...
  *
  * @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"`
  *
@@ -683,9 +711,12 @@ declare function timeout<T extends [unknown, ...unknown[]]>(timeout: number, ...
  * 2. `'allSettled'`: for `PromisE.allSettled`
  * 3. `'any'`: for `PromisE.any`
  * 4. `'race'`: for `PromisE.race`
+ * @param options.onAbort (optional) 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.
+ * @param options.onTimeout (optional) Callback invoked when the promise times out.
+ * Optionally, return an `Error` object to reject the promise with a custom error.
  * @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
  *
@@ -698,7 +729,6 @@ declare function timeout<T extends [unknown, ...unknown[]]>(timeout: number, ...
  *     { // instead of `timeout: number` an object can be used for additional options
  *         func: 'race', // tells PromisE.timeout to use `PromisE.race(promises)`
  *         timeout: 5000, // timeout after 5000ms
- *         timeoutMsg: 'My custom timed out message',
  *     },
  *     PromisE.delay(1000), // resolves after 1000ms with value 1000
  *     () => PromisE.delay(2000), // resolves after 2000ms with value 2000
@@ -707,9 +737,9 @@ declare function timeout<T extends [unknown, ...unknown[]]>(timeout: number, ...
  * // Result: 1000 (Result of `Promise.race(promises)`)
  * ```
  */
-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 function timeout<T extends unknown[], TFunc extends keyof BatchFuncs<T> = keyof BatchFuncs<T>>(options: TimeoutOptions<T, TFunc>, ...values: T): IPromisE_Timeout<TimeoutResult<T, TFunc>>;
 declare namespace timeout {
-    var defaults: Required<Omit<TimeoutOptions<unknown[], keyof TimeoutFunc<[]>>, "abortCtrl" | "signal">>;
+    var defaults: Required<Omit<TimeoutOptions<unknown[], keyof BatchFuncs<[]>>, "abortCtrl" | "signal">>;
 }
 
 /**
@@ -840,4 +870,27 @@ declare const retry: {
     };
 };
 
-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 };
+/** Timeout duration (in milliseconds) used as a fallback when positive number is not provided to {@link timeout} */
+declare const TIMEOUT_FALLBACK = 10000;
+/** Node.js setTimeout limit is 2147483647 (2^31-1). Larger values fire immediately. */
+declare const TIMEOUT_MAX = 2147483647;
+declare class TimeoutPromise<T> extends PromisEBase<T> implements IPromisE_Timeout<T> {
+    readonly data: IPromisE<T>;
+    readonly options: TimeoutOptions;
+    readonly timeout: IPromisE_Delay<T>;
+    readonly started: Date;
+    private _signals?;
+    constructor(data: IPromisE<T>, timeout: IPromisE_Delay<T>, options: TimeoutOptions, _signals?: AbortSignal[]);
+    get abortCtrl(): AbortController | undefined;
+    get aborted(): boolean;
+    cancelAbort(): void;
+    clearTimeout(): void;
+    get timedout(): boolean;
+    private _setup;
+    private _handleAbort;
+    private _handleEarlyFinalize;
+    private _handleFinalize;
+    static defaults: TimeoutOptionsDefault;
+}
+
+export { type BatchFuncs, type DeferredAsyncCallback, type DeferredAsyncDefaults, type DeferredAsyncOptions, type GetPromiseFunc, type IPromisE, type IPromisE_Delay, type IPromisE_Timeout, type OnEarlyFinalize, type OnFinalize, PromisE, PromisEBase, type PromiseParams, ResolveError, ResolveIgnored, type RetryIfFunc, type RetryOptions, TIMEOUT_FALLBACK, TIMEOUT_MAX, type TimeoutOptions, type TimeoutOptionsDefault, TimeoutPromise, type TimeoutResult, PromisE as default, deferred, deferredCallback, delay, delayReject, retry, timeout };

package/dist/index.js

@@ -17,10 +17,16 @@ var _PromisEBase = class _PromisEBase extends Promise {
       _reject = (reason) => {
         reject(reason);
         this._state = 2;
+        this.onFinalize.forEach(
+          (fn) => fallbackIfFails(fn, [void 0, reason], void 0)
+        );
       };
       _resolve = (value) => {
         resolve(value);
         this._state = 1;
+        this.onFinalize.forEach(
+          (fn) => fallbackIfFails(fn, [value, void 0], void 0)
+        );
       };
       if (isFn(input)) {
         fallbackIfFails(input, [_resolve, _reject], _reject);
@@ -34,6 +40,7 @@ var _PromisEBase = class _PromisEBase extends Promise {
     /**
      * callbacks to be invoked whenever PromisE instance is finalized early using non-static resolve()/reject() methods */
     this.onEarlyFinalize = [];
+    this.onFinalize = [];
     //
     //
     // --------------------------- Early resolve/reject ---------------------------
@@ -411,117 +418,141 @@ retry.defaults = {
 };
 var retry_default = retry;
 
+// src/TimeoutPromise.ts
+import { arrUnique, fallbackIfFails as fallbackIfFails5, isObj } from "@superutils/core";
+var TIMEOUT_FALLBACK = 1e4;
+var TIMEOUT_MAX = 2147483647;
+var TimeoutPromise = class extends PromisEBase_default {
+  constructor(data, timeout2, options, _signals) {
+    super(data);
+    this.started = /* @__PURE__ */ new Date();
+    this._setup = () => {
+      var _a, _b, _c, _d;
+      this._signals = arrUnique(
+        [(_b = (_a = this.options) == null ? void 0 : _a.abortCtrl) == null ? void 0 : _b.signal, (_c = this.options) == null ? void 0 : _c.signal].filter(
+          Boolean
+        )
+      );
+      !this.onEarlyFinalize.includes(this._handleEarlyFinalize) && this.onEarlyFinalize.push(this._handleEarlyFinalize);
+      !this.onFinalize.includes(this._handleFinalize) && this.onFinalize.push(this._handleFinalize);
+      (_d = this._signals) == null ? void 0 : _d.forEach(
+        (signal) => signal == null ? void 0 : signal.addEventListener(
+          "abort",
+          this._handleAbort
+        )
+      );
+    };
+    this._handleAbort = async () => {
+      var _a, _b, _c;
+      if (!((_a = this._signals) == null ? void 0 : _a.length) || !this.pending) return;
+      let err = await fallbackIfFails5((_b = this.options) == null ? void 0 : _b.onAbort, [], void 0);
+      err != null ? err : err = new Error(
+        `Aborted after ${(/* @__PURE__ */ new Date()).getTime() - this.started.getTime()}ms`
+      );
+      (_c = err.name) != null ? _c : err.name = "AbortError";
+      this.reject(err);
+    };
+    this._handleEarlyFinalize = () => {
+      var _a, _b, _c, _d;
+      ((_a = this.options) == null ? void 0 : _a.abortOnEarlyFinalize) && ((_d = (_c = (_b = this.options) == null ? void 0 : _b.abortCtrl) == null ? void 0 : _c.abort) == null ? void 0 : _d.call(_c));
+    };
+    // cleanup after execution
+    this._handleFinalize = ((_, err) => {
+      var _a, _b, _c, _d, _e;
+      const failed = !this.timeout.rejected && !((_a = this._signals) == null ? void 0 : _a.find((x) => x == null ? void 0 : x.aborted));
+      if (failed) return;
+      ((_d = (_c = (_b = this.options) == null ? void 0 : _b.abortCtrl) == null ? void 0 : _c.signal) == null ? void 0 : _d.aborted) === false && ((_e = this.options) == null ? void 0 : _e.abortCtrl.abort(err));
+      this.cancelAbort();
+      this.clearTimeout();
+    });
+    this.data = data;
+    this.options = isObj(options) ? options : {};
+    this.timeout = timeout2;
+    this._signals = _signals;
+    this._setup();
+  }
+  get abortCtrl() {
+    return this.options.abortCtrl;
+  }
+  get aborted() {
+    var _a;
+    return this.rejected && !this.timeout.rejected && !!((_a = this._signals) == null ? void 0 : _a.find((s) => s == null ? void 0 : s.aborted));
+  }
+  cancelAbort() {
+    var _a;
+    (_a = this._signals) == null ? void 0 : _a.forEach(
+      (signal) => signal == null ? void 0 : signal.removeEventListener(
+        "abort",
+        this._handleAbort
+      )
+    );
+  }
+  clearTimeout() {
+    clearTimeout(this.timeout.timeoutId);
+  }
+  get timedout() {
+    return this.rejected && this.timeout.rejected;
+  }
+};
+TimeoutPromise.defaults = {
+  abortOnEarlyFinalize: true,
+  batchFunc: "all",
+  timeout: TIMEOUT_FALLBACK
+};
+var TimeoutPromise_default = TimeoutPromise;
+
 // src/timeout.ts
 import {
-  arrUnique,
-  fallbackIfFails as fallbackIfFails5,
+  arrUnique as arrUnique2,
   isFn as isFn4,
-  isObj,
+  isNumber,
+  isObj as isObj2,
   isPositiveNumber as isPositiveNumber2,
-  noop,
   objCopy as objCopy3
 } from "@superutils/core";
-var FALLBACK_TIMEOUT = 1e4;
-function timeout(timeoutOrOptions, ...values) {
-  const options = objCopy3(
+function timeout(options, ...values) {
+  var _a;
+  const opts = objCopy3(
     timeout.defaults,
-    isObj(timeoutOrOptions) ? timeoutOrOptions : { timeout: timeoutOrOptions },
+    isNumber(options) ? { timeout: options } : isObj2(options) ? options : {},
     [],
     "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 ? (
+  opts.timeout = Math.min(
+    isPositiveNumber2(opts.timeout) ? opts.timeout : TIMEOUT_FALLBACK,
+    TIMEOUT_MAX
+  );
+  const promises = values.map(
+    (v) => isFn4(v) ? PromisEBase_default.try(v) : v
+  );
+  const dataPromise = promises.length <= 1 ? (
     // single promise resolves to a single result
-    arrPromises[0] instanceof PromisEBase_default ? arrPromises[0] : new PromisEBase_default(arrPromises[0])
+    promises[0] instanceof PromisEBase_default ? promises[0] : new PromisEBase_default(promises[0])
   ) : (
     // multiple promises resolve to an array of results
-    (isFn4(PromisEBase_default[func]) ? PromisEBase_default[func] : PromisEBase_default.all)(
-      arrPromises
+    (isFn4(PromisEBase_default[opts.batchFunc]) ? PromisEBase_default[opts.batchFunc] : PromisEBase_default.all)(promises)
+  );
+  const timeoutPromise = delayReject_default(opts.timeout, opts.onTimeout);
+  const promise = new TimeoutPromise_default(
+    PromisEBase_default.race([dataPromise, timeoutPromise]),
+    timeoutPromise,
+    opts,
+    arrUnique2(
+      [(_a = opts.abortCtrl) == null ? void 0 : _a.signal, opts.signal].filter(Boolean)
     )
   );
-  const timeoutPromise = delayReject_default(duration, onTimeout);
-  const promise = PromisEBase_default.race([
-    dataPromise,
-    timeoutPromise
-  ]);
-  addPropsNListeners(promise, dataPromise, timeoutPromise, options);
   return promise;
 }
-timeout.defaults = {
-  func: "all",
-  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
-    );
+timeout.defaults = TimeoutPromise_default.defaults;
+Object.defineProperty(timeout, "defaults", {
+  get() {
+    return TimeoutPromise_default.defaults;
+  },
+  set(newDefaults) {
+    TimeoutPromise_default.defaults = newDefaults;
   }
-  signals.forEach((signal2) => signal2.addEventListener("abort", handleAbort));
-};
+});
 
 // src/PromisE.ts
 var PromisE = class extends PromisEBase_default {
@@ -537,11 +568,13 @@ var PromisE_default = PromisE;
 // src/index.ts
 var index_default = PromisE_default;
 export {
-  FALLBACK_TIMEOUT,
   PromisE,
   PromisEBase,
   ResolveError,
   ResolveIgnored,
+  TIMEOUT_FALLBACK,
+  TIMEOUT_MAX,
+  TimeoutPromise,
   index_default as default,
   deferred,
   deferredCallback,

package/package.json

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