@superutils/promise 1.1.4 → 1.1.6

package/README.md

@@ -2,7 +2,7 @@
 
 An extended `Promise` implementation, named `PromisE`, that provides additional features and utilities for easier asynchronous flow control in JavaScript and TypeScript applications.
 
-This package offers a drop-in replacement for the native `Promise` that includes status tracking (`.pending`, `.resolved`, `.rejected`) and a suite of practical static methods for common asynchronous patterns like deferred execution, throttling, and cancellable fetches.
+This package offers a drop-in replacement for the native `Promise` that includes status tracking (`.pending`, `.resolved`, `.rejected`) and a suite of practical static methods for common asynchronous patterns like deferred execution, throttling, auto-retry and timeout.
 
 <div v-if="false">
 
@@ -16,39 +16,52 @@ For full API reference check out the [docs page](https://alien45.github.io/super
 - [Installation](#installation)
 - [Usage](#usage)
     - [`new PromisE(executor)`](#promise-executor): Drop-in replacement for `Promise`
-    - [`new PromisE(promise)`](#promise-status): Check promise status
+        - [Status tracking](#status-tracking)
+        - [Early Finalization](#early-finalization)
+    - [`new PromisE(promise)`](#promise-status): Check status of an existing promise.
     - [`PromisE.try()`](#static-methods): Static methods
     - [`PromisE.delay()`](#delay): Async delay
     - [`PromisE.deferred()`](#deferred): Async debounced/throttled callback
+        - [Debounce Example](#debounce-example)
+        - [Throttle Example](#throttle-example)
+        - [Behavior with different `options`](#behavior-with-different-options)
     - [`PromisE.timeout()`](#timeout): Reject after timeout
 
 ## Features
 
 - **Promise Status**: Easily check if a promise is `pending`, `resolved`, or `rejected`.
 - **Deferred Execution**: Defer or throttle promise-based function calls with `PromisE.deferred()`.
-- **Auto-cancellable Fetch**: Automatically abort pending requests when subsequent requests are made using `PromisE.deferredFetch()` and `PromisE.deferredPost()`.
-- **Auto-cancellable Fetch**: The `PromisE.deferredFetch` and `PromisE.deferredPost` utilities automatically abort pending requests when a new deferred/throttled call is made.
 - **Timeouts**: Wrap any promise with a timeout using `PromisE.timeout()`.
 - **Rich Utilities**: A collection of static methods like `.all()`, `.race()`, `.delay()`, and more, all returning `PromisE` instances.
 
 ## Installation
 
 ```bash
-npm install @superutils/core @superutils/promise
+npm install @superutils/promise
 ```
 
+Dependency: `@superutils/core` will be automatically installed by NPM
+
 ## Usage
 
 <div id="promise-executor"></div>
 
 ### `new PromisE(executor)`: Drop-in replacement for `Promise`
 
-The `PromisE` class can be used just like the native `Promise`. The key difference is the addition of status properties:
+The `PromisE` class is an extension of the built-in `Promise` class and can be used as a drop-in replacement. It is fully compatible with async/await and `Promise` static methods.
 
-```typescript
-import { PromisE } from '@superutils/promise'
+A `PromisE` instance has the following additional features in comparison to `Promise`:
+
+#### Status tracking:
+
+All instances come with `.pending`, `.resolved` and `.rejected` read-only properties that indicate the current state of the promise.
 
-const p = new PromisE(resolve => setTimeout(() => resolve('done'), 1000))
+```javascript
+import Promise from '@superutils/promise'
+
+// Importing `PromisE` as "Promise" allows it to be used as a drop-in replacement without changing existing code
+
+const p = new Promise(resolve => setTimeout(() => resolve('done'), 1000))
 
 console.log(p.pending) // true
 
@@ -59,24 +72,33 @@ p.then(result => {
 })
 ```
 
-and the ability to early finalize a promise:
+#### Early finalization:
+
+All `PromisE` instances expose `.resolve()` and `.reject()` methods that allow early finalization and `.onEarlyFinalize` array that allows adding callbacks to be executed when the promise is finalized externally using these methods.
+
+```javascript
+import PromisE from '@superutils/promise'
 
-```typescript
-import { PromisE } from '@superutils/promise'
 const p = new PromisE(resolve => setTimeout(() => resolve('done'), 10000))
 p.then(result => console.log(result))
 // resolve the promise early
 setTimeout(() => p.resolve('finished early'), 500)
+
+// Add a callback to do stuff whenever promise is finalized externally.
+// This will not be invoked if promise finalized naturally using the Promise executor.
+p.onEarlyFinalize.push(((resolved, valueOrReason) =>
+	console.log('Promise finalized externally:', { resolved, valueOrReason }),
+))
 ```
 
 <div id="static-methods"></div>
 
-### `PromisE.try(fn)`: Static methods
+### Static methods
 
 Drop-in replacement for all `Promise` static methods such as `.all()`, `.race()`, `.reject`, `.resolve`, `.try()`, `.withResolvers()`....
 
-```typescript
-import { PromisE } from '@superutils/promise'
+```javascript
+import PromisE from '@superutils/promise'
 
 const p = PromisE.try(() => {
 	throw new Error('Something went wrong')
@@ -90,12 +112,11 @@ p.catch(error => {
 
 <div id="promise-status"></div>
 
-### `new PromisE(promise)`
+### `new PromisE(promise)`: Check status of an existing promise.
 
-Check status of an existing promise.
+```javascript
+import PromisE from '@superutils/promise'
 
-```typescript
-import { PromisE } from '@superutils/promise'
 const x = Promise.resolve(1)
 const p = new PromisE(x)
 console.log(p.pending) // false
@@ -109,8 +130,9 @@ console.log(p.rejected) // false
 
 Creates a promise that resolves after a specified duration, essentially a promise-based `setTimeout`.
 
-```typescript
+```javascript
 import PromisE from '@superutils/promise'
+
 // Wait until `appReady` becomes truthy but
 while (!appReady) {
 	await PromisE.delay(100)
@@ -123,16 +145,13 @@ Creates a promise that executes a function after a specified duration and return
 
 If callback returns undefined, default value will be the duration.
 
-```typescript
+```javascript
 import PromisE from '@superutils/promise'
 
-const func = async () => {
-	console.log('Waiting for app initialization or something else to be ready')
-	// wait 3 seconds before proceeding
-	await PromisE.delay(3000)
-	console.log('App ready')
-}
-func()
+console.log('Waiting for app initialization or something else to be ready')
+const onReady = () => console.log('App ready')
+
+PromisE.delay(3000, onReady)
 ```
 
 <div id="deferred"></div>
@@ -144,6 +163,8 @@ Create a function that debounces or throttles promise-returning function calls.
 #### Debounce example:
 
 ```typescript
+import PromisE from '@superutils/promise'
+
 const example = async (options = {}) => {
 	const df = PromisE.deferred({
 		delayMs: 100,
@@ -165,7 +186,10 @@ example({ ignoreStale: true, throttle: false })
 
 #### Throttle example:
 
-```typescript
+```javascript
+import PromisE from '@superutils/promise'
+
+// Simulate an example scenario
 const example = async (options = {}) => {
 	const df = PromisE.deferred({
 		delayMs: 100,
@@ -185,6 +209,22 @@ example({ ignoreStale: false, throttle: true })
 // `200` and `5000` will be printed in the console
 ```
 
+#### Behavior with different `options`:
+
+- **`delayMs: PositiveNumber, throttle: false`**: (default) Debounce mode.
+- **`throttle: true`**: Switches from debounce to throttle mode.
+- **`delayMs: 0`**: Disables debouncing and throttling, enabling sequential/queue mode. Requests are executed one after the other. Any failed promise does not affect subsequent promises.
+- **`resolveIgnored` (enum)**: Controls how an ignored promises is handled.
+    1. `ResolveIgnored.WITH_UNDEFINED`: The promise for the ignored request resolves with `undefined`.
+    2. `ResolveIgnored.WITH_LAST`: The promise for the ignored request waits (if needed) and resolves with the last/most-recent finalized promise.
+    3. `ResolveIgnored.NEVER`: The promise for the ignored request is neither resolved nor rejected. It will remain pending indefinitely.
+        > **Warning:** Use with caution, as this may lead to memory leaks if not handled properly.
+- **`resolveError` (enum)**: Controls how failed requests are handled.
+    1.  `ResolveError.NEVER`: The promise for a failed request will neither resolve nor reject, causing it to remain pending indefinitely.
+        > **Warning:** Use with caution, as this may lead to memory leaks if not handled properly.
+    2.  `ResolveError.WITH_ERROR`: The promise resolves with the error object instead of being rejected.
+    3.  `ResolveError.WITH_UNDEFINED`: The promise resolves with an `undefined` value upon failure.
+
 <div id="deferredCallback"></div>
 
 ### `PromisE.deferredCallback(callback, options)`: async debounced/throttled callbacks
@@ -221,7 +261,7 @@ delays.forEach(timeout =>
 #### Reject stuck or unexpectedly lenghthy promise(s) after a specified timeout:
 
 ```typescript
-import { PromisE } from '@superutils/promise'
+import PromisE from '@superutils/promise'
 
 PromisE.timeout(
 	5000, // timeout after 5000ms
@@ -233,13 +273,13 @@ PromisE.timeout(
 #### Show a message when loading is too long:
 
 ```typescript
-import { PromisE } from '@superutils/promise'
+import PromisE from '@superutils/promise'
 
-const loadUserNProducts = () => {
+const loadUserNProducts = async () => {
 	const promise = PromisE.timeout(
 		5000, // timeout after 5000ms
-		api.getUser(),
-		api.getProducts(),
+		fetch('https://dummyjson.com/users/1'), // fetch user
+		fetch('https://dummyjson.com/products'), // fetch products
 	)
 	const [user, products] = await promise.catch(err => {
 		// promise did not time out, but was rejected
@@ -254,5 +294,5 @@ const loadUserNProducts = () => {
 	})
 	return [user, products]
 }
-loadUserNProducts()
+loadUserNProducts().catch(console.warn)
 ```

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _superutils_core from '@superutils/core';
-import { ValueOrPromise, TimeoutId, PositiveNumber, ThrottleOptions, DeferredOptions } from '@superutils/core';
+import { ValueOrPromise, TimeoutId, PositiveNumber, DeferredOptions } from '@superutils/core';
 
 interface IPromisE<T = unknown> extends Promise<T> {
     /** 0: pending, 1: resolved, 2: rejected */
@@ -79,9 +79,11 @@ type PromiseParams<T = unknown> = ConstructorParameters<typeof Promise<T>>;
 
 /** Return type of `PromisE.deferred()` */
 type DeferredAsyncCallback<TArgs extends unknown[] | [] = []> = <TResult = unknown>(promise: Promise<TResult> | ((...args: TArgs) => Promise<TResult>)) => IPromisE<TResult>;
-type DeferredAsyncGetPromise<T> = <TResult = T>() => Promise<TResult>;
+type GetPromiseFunc<T> = <TResult = T>() => Promise<TResult>;
 /** Default options used by `PromisE.deferred` and related functions */
-type DeferredAsyncDefaults<ThisArg = unknown, Delay = unknown> = Pick<Required<DeferredAsyncOptions<ThisArg, Delay>>, 'delayMs' | 'resolveError' | 'resolveIgnored'>;
+type DeferredAsyncDefaults<ThisArg = unknown, Delay = unknown> = Pick<Required<DeferredAsyncOptions<ThisArg, Delay>>, 'resolveError' | 'resolveIgnored'> & {
+    delayMs: number;
+};
 /** Options for `PromisE.deferred` and other related functions */
 type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
     /**
@@ -100,14 +102,12 @@ type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
      * Default: `false`
      */
     ignoreStale?: boolean;
-    /** Callback invoked whenever promise/function throws error */
-    onError?: (this: ThisArg, err: unknown) => ValueOrPromise<unknown>;
     /**
      * Whenever a promise/function is ignored when in debounce/throttle mode, `onIgnored` wil be invoked.
      * The promise/function will not be invoked, unless it's manually invoked using the `ignored` function.
      * Use for debugging or logging purposes.
      */
-    onIgnore?: (this: ThisArg, ignored: DeferredAsyncGetPromise<unknown>) => ValueOrPromise<unknown>;
+    onIgnore?: (this: ThisArg, ignored: GetPromiseFunc<unknown>) => ValueOrPromise<unknown>;
     /**
      * Whenever a promise/function is executed successfully `onResult` will be called.
      * Those that are ignored but resolve with last will not cause `onResult` to be invoked.
@@ -125,18 +125,17 @@ type DeferredAsyncOptions<ThisArg = unknown, Delay = unknown> = {
      * See {@link ResolveError} for available options.
      */
     resolveError?: ResolveError;
-    /** The value to be used as "thisArg" whenever any of the callbacks are invoked */
-    thisArg?: ThisArg;
 } & (({
-    delayMs: PositiveNumber<Delay>;
-    throttle: true;
-} & Pick<ThrottleOptions, 'trailing'>) | ({
-    delayMs?: PositiveNumber<Delay>;
-    throttle?: false;
-} & Pick<DeferredOptions, 'leading'>) | {
     delayMs: 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;
+}) | ({
+    delayMs?: PositiveNumber<Delay>;
+} & DeferredOptions<ThisArg>));
 /** Determines what to do when deferred promise/function fails */
 declare enum ResolveError {
     /** Neither resolve nor reject the failed */
@@ -161,6 +160,8 @@ declare enum ResolveIgnored {
     WITH_UNDEFINED = "WITH_UNDEFINED"
 }
 
+/** 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 */
 type RetryOptions<T = unknown> = {
     /**
@@ -179,30 +180,47 @@ type RetryOptions<T = unknown> = {
      */
     retryBackOff?: 'exponential' | 'linear';
     /**
-     * Delay in milliseconds between retries.
+     * Minimum delay in milliseconds between retries.
      * Default: `300`
      */
     retryDelay?: number;
     /**
-     * Add a random delay between 0ms and `retryDelayJitterMax` to the `retryDelay`.
+     * Whether to add a random delay between 0ms and `retryDelayJitterMax` to the `retryDelay`.
+     *
+     * This helps to avoid "thundering herd" problem when multiple retries are attempted simultaneously.
+     *
      * Default: `true`
      */
     retryDelayJitter?: boolean;
     /**
-     * Maximum delay (in milliseconds) to be used when randomly generating jitter delay duration.
+     * Maximum jitter delay (in milliseconds) to be added to the `retryDelay` when `retryDelayJitter` is `true`.
+     *
+     * A random value between `0` and `retryDelayJitterMax` will be added to the base `retryDelay`.
+     *
      * Default: `100`
      */
     retryDelayJitterMax?: number;
     /**
-     * Additional condition/function to be used to determine whether function should be retried.
-     * `retryIf` will only be executed when function execution is successful.
+     * Additional condition to be used to determine whether function should be retried.
+     *
+     * If `retryIf` not provided, execution will be retried on any error until the retry limit is reached
+     * or a result is received without an exception.
+     *
+     * @param prevResult The result from the previous attempt, if any.
+     * @param retryCount The number of retries that have been attempted so far.
+     * @param error The error from the previous attempt, if any.
+     *
+     * Expected return values:
+     * - `true`: retry will be attempted regardless of error.
+     * - `false`: no further retry will be attempted and the last error/result will be returned.
+     * - `void | undefined`: retry will be attempted only if there was an error.
      */
-    retryIf?: null | ((prevResult: T | undefined, retryCount: number) => boolean | Promise<boolean>);
+    retryIf?: RetryIfFunc<T>;
 };
 
 declare class PromisEBase<T = unknown> extends Promise<T> implements IPromisE<T> {
-    private _resolve?;
-    private _reject?;
+    private _resolve;
+    private _reject;
     private _state;
     /**
      * callbacks to be invoked whenever PromisE instance is finalized early using non-static resolve()/reject() methods */
@@ -213,6 +231,8 @@ declare class PromisEBase<T = unknown> extends Promise<T> implements IPromisE<T>
     constructor(promise: Promise<T>);
     /** Create a resolved promise with value */
     constructor(value: T);
+    /** Create a promise to be resolved externally using `.resolve()` and `.reject()` methods */
+    constructor(value: undefined);
     /**
      * If executor function is not provided, the promise must be resolved/rejected externally.
      *
@@ -312,7 +332,8 @@ type TimeoutOptions<Func extends string = 'all'> = {
 
 /**
  * @function PromisE.deferred
- * The adaptation of the `deferred()` function tailored for Promises.
+ *
+ * The adaptation of the `deferred()` function from `@superutils/core` tailored for Promises.
  *
  *
  * # Notes
@@ -771,4 +792,4 @@ declare const retry: {
     };
 };
 
-export { type DeferredAsyncCallback, type DeferredAsyncDefaults, type DeferredAsyncGetPromise, type DeferredAsyncOptions, type IPromisE, type IPromisE_Delay, type IPromisE_Timeout, type OnEarlyFinalize, PromisE, PromisEBase, type PromiseParams, ResolveError, ResolveIgnored, type RetryOptions, type TimeoutFunc, type TimeoutOptions, PromisE as default, deferred, deferredCallback, delay, delayReject, retry, timeout };
+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 };

package/dist/index.js

@@ -1,33 +1,34 @@
 // src/deferred.ts
 import {
-  deferred as deferredCore,
+  deferred as deferredSync,
   fallbackIfFails as fallbackIfFails2,
   isFn as isFn2,
   isPositiveNumber,
-  objCopy,
-  throttled as throttledCore
+  objCopy
 } from "@superutils/core";
 
 // src/PromisEBase.ts
 import { fallbackIfFails, isFn, isPromise } from "@superutils/core";
 var _PromisEBase = class _PromisEBase extends Promise {
   constructor(input) {
-    if (input instanceof _PromisEBase) return input;
     let _resolve;
     let _reject;
     super((resolve, reject) => {
       _reject = (reason) => {
-        this._state = 2;
         reject(reason);
+        this._state = 2;
       };
       _resolve = (value) => {
-        this._state = 1;
         resolve(value);
+        this._state = 1;
       };
-      input != null ? input : input = () => {
-      };
-      const promise = isPromise(input) ? input : isFn(input) ? new globalThis.Promise(input) : Promise.resolve(input);
-      promise.then(_resolve, _reject);
+      if (isFn(input)) {
+        fallbackIfFails(input, [_resolve, _reject], _reject);
+      } else if (isPromise(input)) {
+        input.then(_resolve, _reject);
+      } else if (input !== void 0) {
+        _resolve(input);
+      }
     });
     this._state = 0;
     /**
@@ -66,15 +67,15 @@ var _PromisEBase = class _PromisEBase extends Promise {
   //
   /** Indicates if the promise is still pending/unfinalized */
   get pending() {
-    return this._state === 0;
+    return this.state === 0;
   }
   /** Indicates if the promise has been rejected */
   get rejected() {
-    return this._state === 2;
+    return this.state === 2;
   }
   /** Indicates if the promise has been resolved */
   get resolved() {
-    return this._state === 1;
+    return this.state === 1;
   }
   /**
    * Get promise status code:
@@ -186,12 +187,14 @@ function deferred(options = {}) {
   let { onError, onIgnore, onResult } = options;
   const {
     delayMs = 0,
+    ignoreStale,
     resolveError,
     resolveIgnored,
     thisArg,
     throttle
   } = options;
-  let prevQItem = null;
+  let lastInSeries = null;
+  let lastExecuted;
   const queue = /* @__PURE__ */ new Map();
   const isSequential = !isPositiveNumber(delayMs);
   if (thisArg !== void 0) {
@@ -199,17 +202,21 @@ function deferred(options = {}) {
     onIgnore = onIgnore == null ? void 0 : onIgnore.bind(thisArg);
     onResult = onResult == null ? void 0 : onResult.bind(thisArg);
   }
-  const handleIgnore = (items, prevQItem2) => {
+  const handleIgnore = (items) => {
     for (const [iId, iItem] of items) {
       queue.delete(iId);
-      if (iItem === void 0 || iItem.started) continue;
-      onIgnore && fallbackIfFails2(onIgnore, [iItem.getPromise], 0);
+      const isStale = ignoreStale && iItem.sequence < lastExecuted.sequence;
+      if (iItem.resolved || iItem.started && !isStale) continue;
+      if (iItem.started) {
+        iItem.getPromise = (() => iItem.result);
+      }
+      fallbackIfFails2(onIgnore, [iItem.getPromise], 0);
       switch (resolveIgnored) {
         case "WITH_UNDEFINED" /* WITH_UNDEFINED */:
           iItem.resolve(void 0);
           break;
         case "WITH_LAST" /* WITH_LAST */:
-          prevQItem2 == null ? void 0 : prevQItem2.then(iItem.resolve, iItem.reject);
+          lastExecuted == null ? void 0 : lastExecuted.then(iItem.resolve, iItem.reject);
           break;
         case "NEVER" /* NEVER */:
           break;
@@ -218,33 +225,32 @@ function deferred(options = {}) {
     if (!queue.size) sequence = 0;
   };
   const handleRemaining = (currentId) => {
-    const _prevQItem = prevQItem;
-    prevQItem = null;
+    lastInSeries = null;
     if (isSequential) {
       queue.delete(currentId);
       const [nextId, nextItem] = [...queue.entries()][0] || [];
       return nextId && nextItem && handleItem(nextId, nextItem);
     }
     let items = [...queue.entries()];
-    if (throttle && options.trailing) {
+    if (throttle === true && options.trailing) {
       const currentIndex = items.findIndex(([id]) => id === currentId);
       items = items.slice(0, currentIndex);
     } else if (!throttle) {
       items = items.slice(0, -1);
     }
-    handleIgnore(items, _prevQItem);
+    handleIgnore(items);
+    queue.delete(currentId);
   };
-  let prevSeq = 0;
   const executeItem = async (id, qItem) => {
     var _a;
-    qItem.started = true;
-    const _prevQItem = prevQItem;
-    prevQItem = qItem;
-    prevSeq = (_a = prevQItem == null ? void 0 : prevQItem.sequence) != null ? _a : 0;
     try {
-      const result = await PromisEBase_default.try(qItem.getPromise);
-      const ignore = !isSequential && options.ignoreStale && prevSeq > qItem.sequence;
-      if (ignore) return handleIgnore([[id, qItem]], _prevQItem);
+      qItem.started = true;
+      lastExecuted = qItem;
+      lastInSeries = qItem;
+      (_a = qItem.result) != null ? _a : qItem.result = PromisEBase_default.try(qItem.getPromise);
+      const result = await qItem.result;
+      const isStale = !!ignoreStale && qItem.sequence < lastExecuted.sequence;
+      if (isStale) return handleIgnore([[id, qItem]]);
       qItem.resolve(result);
       onResult && fallbackIfFails2(onResult, [result], void 0);
     } catch (err) {
@@ -265,22 +271,21 @@ function deferred(options = {}) {
     }
     handleRemaining(id);
   };
-  const handleItem = isSequential ? executeItem : (throttle ? throttledCore : deferredCore)(
+  const handleItem = isSequential ? executeItem : deferredSync(
     executeItem,
     delayMs,
     options
   );
-  const deferredFunc = (promise) => {
+  return (promise) => {
     const id = /* @__PURE__ */ Symbol("deferred-queue-item-id");
     const qItem = new PromisEBase_default();
     qItem.getPromise = isFn2(promise) ? promise : () => promise;
     qItem.started = false;
     qItem.sequence = ++sequence;
     queue.set(id, qItem);
-    if (!prevQItem || !isSequential) handleItem(id, qItem);
+    if (!lastInSeries || !isSequential) handleItem(id, qItem);
     return qItem;
   };
-  return deferredFunc;
 }
 deferred.defaults = {
   /**
@@ -348,6 +353,7 @@ import {
   objCopy as objCopy2
 } from "@superutils/core";
 var retry = async (func, options) => {
+  var _a, _b;
   options = objCopy2(retry.defaults, options != null ? options : {}, [], (key, value) => {
     switch (key) {
       // case 'retryDelayJitter':
@@ -377,18 +383,21 @@ var retry = async (func, options) => {
     if (retryBackOff === "exponential" && retryCount > 1) _retryDelay *= 2;
     if (retryDelayJitter)
       _retryDelay += Math.floor(Math.random() * retryDelayJitterMax);
-    retryCount > 0 && await delay_default(_retryDelay);
+    if (retryCount > 0) await delay_default(_retryDelay);
     try {
       error = void 0;
       result = await func();
     } catch (err) {
       error = err;
     }
-    shouldRetry = maxRetries > 0 && retryCount < maxRetries && (!!error || !!await fallbackIfFails4(
-      options.retryIf,
-      [result, retryCount],
-      false
-    ));
+    if (maxRetries === 0 || retryCount >= maxRetries) break;
+    shouldRetry = !!((_b = await fallbackIfFails4(
+      (_a = options.retryIf) != null ? _a : error,
+      // if `retryIf` not provided, retry on error
+      [result, retryCount, error],
+      error
+      // if `retryIf` throws error, default to retry on error
+    )) != null ? _b : error);
   } while (shouldRetry);
   if (error !== void 0) return Promise.reject(error);
   return result;

package/package.json

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