@common.js/p-retry 6.2.1 → 8.0.1

package/README.md

@@ -2,4 +2,4 @@
 
 The [p-retry](https://www.npmjs.com/package/p-retry) package exported as CommonJS modules.
 
-Exported from [p-retry@6.2.1](https://www.npmjs.com/package/p-retry/v/6.2.1) using https://github.com/etienne-martin/common.js.
+Exported from [p-retry@8.0.0](https://www.npmjs.com/package/p-retry/v/8.0.0) using https://github.com/etienne-martin/common.js.

package/index.d.ts

@@ -1,36 +1,78 @@
-import {type OperationOptions} from 'retry';
-
 export class AbortError extends Error {
 	readonly name: 'AbortError';
 	readonly originalError: Error;
 
 	/**
-	Abort retrying and reject the promise.
+	Abort retrying and reject the promise. No callback functions will be called.
 
 	@param message - An error message or a custom error.
 	*/
 	constructor(message: string | Error);
 }
 
-export type FailedAttemptError = {
+export type RetryContext = {
+	readonly error: Error;
 	readonly attemptNumber: number;
 	readonly retriesLeft: number;
-} & Error;
+	readonly retriesConsumed: number;
+
+	/**
+	The delay in milliseconds before the next retry attempt.
+
+	This is calculated based on `minTimeout`, `factor`, `maxTimeout`, and `randomize` options.
+
+	Note: The actual delay may be shorter if it would exceed `maxRetryTime`.
+	This is `0` when the retry is skipped or when no retry will occur based on the checks completed before the current callback runs.
+	*/
+	readonly retryDelay: number;
+};
 
 export type Options = {
 	/**
-	Callback invoked on each retry. Receives the error thrown by `input` as the first argument with properties `attemptNumber` and `retriesLeft` which indicate the current attempt number and the number of attempts left, respectively.
+	Callback invoked on each failure. Receives a context object containing the error and retry state information.
+
+	The function is called after `shouldConsumeRetry` and before `shouldRetry`, for all errors except `AbortError`.
+
+	The function is not called on `AbortError`.
+
+	@example
+	```
+	import pRetry from 'p-retry';
+
+	const run = async () => {
+		const response = await fetch('https://sindresorhus.com/unicorn');
+
+		if (!response.ok) {
+			throw new Error(response.statusText);
+		}
+
+		return response.json();
+	};
+
+	const result = await pRetry(run, {
+		onFailedAttempt: ({error, attemptNumber, retriesLeft, retriesConsumed, retryDelay}) => {
+			console.log(`Attempt ${attemptNumber} failed. Retrying in ${retryDelay}ms. ${retriesLeft} retries left.`);
+			// 1st request => Attempt 1 failed. Retrying in 1000ms. 5 retries left.
+			// 2nd request => Attempt 2 failed. Retrying in 2000ms. 4 retries left.
+			// …
+		},
+		retries: 5
+	});
+
+	console.log(result);
+	```
 
 	The `onFailedAttempt` function can return a promise. For example, to add a [delay](https://github.com/sindresorhus/delay):
 
+	@example
 	```
 	import pRetry from 'p-retry';
 	import delay from 'delay';
 
-	const run = async () => { ... };
+	const run = async () => { … };
 
 	const result = await pRetry(run, {
-		onFailedAttempt: async error => {
+		onFailedAttempt: async () => {
 			console.log('Waiting for 1 second before retrying');
 			await delay(1000);
 		}
@@ -39,14 +81,14 @@ export type Options = {
 
 	If the `onFailedAttempt` function throws, all retries will be aborted and the original promise will reject with the thrown error.
 	*/
-	readonly onFailedAttempt?: (error: FailedAttemptError) => void | Promise<void>;
+	readonly onFailedAttempt?: (context: RetryContext) => void | Promise<void>;
 
 	/**
-	Decide if a retry should occur based on the error. Returning true triggers a retry, false aborts with the error.
+	Decide if a retry should occur based on the context. Returning true triggers a retry, false aborts with the error.
 
-	It is not called for `TypeError` (except network errors) and `AbortError`.
+	The function is called after `onFailedAttempt` and `shouldConsumeRetry`.
 
-	@param error - The error thrown by the input function.
+	The function is not called on `AbortError`, `TypeError` (except network errors), or if `retries` or `maxRetryTime` are exhausted.
 
 	@example
 	```
@@ -55,13 +97,91 @@ export type Options = {
 	const run = async () => { … };
 
 	const result = await pRetry(run, {
-		shouldRetry: error => !(error instanceof CustomError);
+		shouldRetry: ({error, attemptNumber, retriesLeft}) => !(error instanceof CustomError)
 	});
 	```
 
 	In the example above, the operation will be retried unless the error is an instance of `CustomError`.
+
+	If the `shouldRetry` function throws, all retries will be aborted and the original promise will reject with the thrown error.
+	*/
+	readonly shouldRetry?: (context: RetryContext) => boolean | Promise<boolean>;
+
+	/**
+	Decide if this failure should consume a retry from the `retries` budget.
+
+	When `false` is returned, the failure will not consume a retry or increment backoff values, but is still subject to `maxRetryTime`.
+
+	The function is called before `onFailedAttempt` and `shouldRetry`.
+
+	The function is not called on `AbortError`.
+
+	@example
+	```
+	import pRetry from 'p-retry';
+
+	const run = async () => { … };
+
+	const result = await pRetry(run, {
+		retries: 2,
+		shouldConsumeRetry: ({error, retriesLeft}) => {
+			console.log(`Retries left: ${retriesLeft}`);
+			return !(error instanceof RateLimitError);
+		},
+	});
+	```
+
+	In the example above, `RateLimitError`s will not decrement the available `retries`.
+
+	If the `shouldConsumeRetry` function throws, all retries will be aborted and the original promise will reject with the thrown error.
 	*/
-	readonly shouldRetry?: (error: FailedAttemptError) => boolean | Promise<boolean>;
+	readonly shouldConsumeRetry?: (context: RetryContext) => boolean | Promise<boolean>;
+
+	/**
+	The maximum amount of times to retry the operation.
+
+	@default 10
+	*/
+	readonly retries?: number;
+
+	/**
+	The exponential factor to use.
+
+	@default 2
+	*/
+	readonly factor?: number;
+
+	/**
+	The number of milliseconds before starting the first retry.
+
+	Set this to `0` to retry immediately with no delay.
+
+	@default 1000
+	*/
+	readonly minTimeout?: number;
+
+	/**
+	The maximum number of milliseconds between two retries.
+
+	@default Infinity
+	*/
+	readonly maxTimeout?: number;
+
+	/**
+	Randomizes the timeouts by multiplying with a factor between 1 and 2.
+
+	@default false
+	*/
+	readonly randomize?: boolean;
+
+	/**
+	The maximum time (in milliseconds) that the retried operation is allowed to run.
+
+	@default Infinity
+
+	Measured with a monotonic clock (`performance.now()`) so system clock adjustments do not affect the limit.
+	*/
+	readonly maxRetryTime?: number;
 
 	/**
 	You can abort retrying using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
@@ -84,22 +204,31 @@ export type Options = {
 	}
 	```
 	*/
-	readonly signal?: AbortSignal;
-} & OperationOptions;
+	readonly signal?: AbortSignal | undefined;
+
+	/**
+	Prevents retry timeouts from keeping the process alive.
+
+	Only affects platforms with a `.unref()` method on timeouts, such as Node.js.
+
+	@default false
+	*/
+	readonly unref?: boolean;
+};
 
 /**
 Returns a `Promise` that is fulfilled when calling `input` returns a fulfilled promise. If calling `input` returns a rejected promise, `input` is called again until the max retries are reached, it then rejects with the last rejection reason.
 
-Does not retry on most `TypeErrors`, with the exception of network errors. This is done on a best case basis as different browsers have different [messages](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful) to indicate this.
-See [whatwg/fetch#526 (comment)](https://github.com/whatwg/fetch/issues/526#issuecomment-554604080)
+Does not retry on most `TypeErrors`, with the exception of network errors. This is done on a best case basis as different browsers have different [messages](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful) to indicate this. See [whatwg/fetch#526 (comment)](https://github.com/whatwg/fetch/issues/526#issuecomment-554604080)
+
+Non-network `TypeError`s always abort retries, even if `shouldConsumeRetry` or `shouldRetry` would otherwise allow another attempt.
 
 @param input - Receives the number of attempts as the first argument and is expected to return a `Promise` or any value.
-@param options - Options are passed to the [`retry`](https://github.com/tim-kos/node-retry#retryoperationoptions) module.
+@param options - Options for configuring the retry behavior.
 
 @example
 ```
 import pRetry, {AbortError} from 'p-retry';
-import fetch from 'node-fetch';
 
 const run = async () => {
 	const response = await fetch('https://sindresorhus.com/unicorn');
@@ -113,22 +242,26 @@ const run = async () => {
 };
 
 console.log(await pRetry(run, {retries: 5}));
-
-// With the `onFailedAttempt` option:
-const result = await pRetry(run, {
-	onFailedAttempt: error => {
-		console.log(`Attempt ${error.attemptNumber} failed. There are ${error.retriesLeft} retries left.`);
-		// 1st request => Attempt 1 failed. There are 4 retries left.
-		// 2nd request => Attempt 2 failed. There are 3 retries left.
-		// …
-	},
-	retries: 5
-});
-
-console.log(result);
 ```
 */
 export default function pRetry<T>(
-	input: (attemptCount: number) => PromiseLike<T> | T,
+	input: (attemptNumber: number) => PromiseLike<T> | T,
 	options?: Options
 ): Promise<T>;
+
+/**
+Wrap a function so that each call is automatically retried on failure.
+
+@example
+```
+import {makeRetriable} from 'p-retry';
+
+const fetchWithRetry = makeRetriable(fetch, {retries: 5});
+
+const response = await fetchWithRetry('https://sindresorhus.com/unicorn');
+```
+*/
+export function makeRetriable<Arguments extends readonly unknown[], Result>(
+	function_: (...arguments_: Arguments) => PromiseLike<Result> | Result,
+	options?: Options
+): (...arguments_: Arguments) => Promise<Result>;

package/index.js

@@ -14,9 +14,11 @@ _export(exports, {
     },
     default: function() {
         return pRetry;
+    },
+    makeRetriable: function() {
+        return makeRetriable;
     }
 });
-var _retry = /*#__PURE__*/ _interopRequireDefault(require("retry"));
 var _isNetworkError = /*#__PURE__*/ _interopRequireDefault(require("is-network-error"));
 function _assertThisInitialized(self) {
     if (self === void 0) {
@@ -310,7 +312,42 @@ var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
         };
     }
 };
-var _options, _options1, _options2;
+var _options, _options1, _options2, _options3, _options4, _options5, _options6, _options7, _options8;
+function validateRetries(retries) {
+    if (typeof retries === "number") {
+        if (retries < 0) {
+            throw new TypeError("Expected `retries` to be a non-negative number.");
+        }
+        if (Number.isNaN(retries)) {
+            throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+        }
+    } else if (retries !== undefined) {
+        throw new TypeError("Expected `retries` to be a number or Infinity.");
+    }
+}
+function validateNumberOption(name, value) {
+    var ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, _min = ref.min, min = _min === void 0 ? 0 : _min, _allowInfinity = ref.allowInfinity, allowInfinity = _allowInfinity === void 0 ? false : _allowInfinity;
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new TypeError("Expected `".concat(name, "` to be a number").concat(allowInfinity ? " or Infinity" : "", "."));
+    }
+    if (!allowInfinity && !Number.isFinite(value)) {
+        throw new TypeError("Expected `".concat(name, "` to be a finite number."));
+    }
+    if (value < min) {
+        throw new TypeError("Expected `".concat(name, "` to be ≥ ").concat(min, "."));
+    }
+}
+function validateFunctionOption(name, value) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value !== "function") {
+        throw new TypeError("Expected `".concat(name, "` to be a function."));
+    }
+}
 var AbortError = /*#__PURE__*/ function(Error1) {
     "use strict";
     _inherits(AbortError, Error1);
@@ -332,141 +369,303 @@ var AbortError = /*#__PURE__*/ function(Error1) {
     }
     return AbortError;
 }(_wrapNativeSuper(Error));
-var decorateErrorWithCounts = function(error, attemptNumber, options) {
-    // Minus 1 from attemptNumber because the first attempt does not count as a retry
-    var retriesLeft = options.retries - (attemptNumber - 1);
-    error.attemptNumber = attemptNumber;
-    error.retriesLeft = retriesLeft;
-    return error;
-};
-function pRetry(input, options) {
+function calculateDelay(retriesConsumed, options) {
+    var attempt = Math.max(1, retriesConsumed + 1);
+    var random = options.randomize ? Math.random() + 1 : 1;
+    var timeout = Math.round(random * options.minTimeout * Math.pow(options.factor, attempt - 1));
+    timeout = Math.min(timeout, options.maxTimeout);
+    return timeout;
+}
+function calculateRemainingTime(start, max) {
+    if (!Number.isFinite(max)) {
+        return max;
+    }
+    return max - (performance.now() - start);
+}
+function delayForRetry(delay, options) {
+    return _delayForRetry.apply(this, arguments);
+}
+function _delayForRetry() {
+    _delayForRetry = _asyncToGenerator(function(delay, options) {
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (delay <= 0) {
+                        return [
+                            2
+                        ];
+                    }
+                    return [
+                        4,
+                        new Promise(function(resolve, reject) {
+                            var ref;
+                            var onAbort = function() {
+                                var ref;
+                                clearTimeout(timeoutToken);
+                                (ref = options.signal) === null || ref === void 0 ? void 0 : ref.removeEventListener("abort", onAbort);
+                                reject(options.signal.reason);
+                            };
+                            var timeoutToken = setTimeout(function() {
+                                var ref;
+                                (ref = options.signal) === null || ref === void 0 ? void 0 : ref.removeEventListener("abort", onAbort);
+                                resolve();
+                            }, delay);
+                            if (options.unref) {
+                                var ref1;
+                                (ref1 = timeoutToken.unref) === null || ref1 === void 0 ? void 0 : ref1.call(timeoutToken);
+                            }
+                            (ref = options.signal) === null || ref === void 0 ? void 0 : ref.addEventListener("abort", onAbort, {
+                                once: true
+                            });
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _delayForRetry.apply(this, arguments);
+}
+function onAttemptFailure(_) {
+    return _onAttemptFailure.apply(this, arguments);
+}
+function _onAttemptFailure() {
+    _onAttemptFailure = _asyncToGenerator(function(param) {
+        var error, attemptNumber, retriesConsumed, startTime, options, ref, ref1, normalizedError, retriesLeft, _maxRetryTime, maxRetryTime, delayTime, remainingTimeBeforeCallbacks, context, consumeRetryContext, consumeRetry, effectiveDelay, context1, remainingTime, remainingTimeAfterShouldRetry, ref2, finalDelay;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    error = param.error, attemptNumber = param.attemptNumber, retriesConsumed = param.retriesConsumed, startTime = param.startTime, options = param.options;
+                    normalizedError = _instanceof(error, Error) ? error : new TypeError('Non-error was thrown: "'.concat(error, '". You should only throw errors.'));
+                    if (_instanceof(normalizedError, AbortError)) {
+                        throw normalizedError.originalError;
+                    }
+                    retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
+                    maxRetryTime = (_maxRetryTime = options.maxRetryTime) !== null && _maxRetryTime !== void 0 ? _maxRetryTime : Number.POSITIVE_INFINITY;
+                    delayTime = calculateDelay(retriesConsumed, options);
+                    remainingTimeBeforeCallbacks = calculateRemainingTime(startTime, maxRetryTime);
+                    if (!(remainingTimeBeforeCallbacks <= 0)) return [
+                        3,
+                        2
+                    ];
+                    context = Object.freeze({
+                        error: normalizedError,
+                        attemptNumber: attemptNumber,
+                        retriesLeft: retriesLeft,
+                        retriesConsumed: retriesConsumed,
+                        retryDelay: 0
+                    });
+                    return [
+                        4,
+                        options.onFailedAttempt(context)
+                    ];
+                case 1:
+                    _state.sent();
+                    throw normalizedError;
+                case 2:
+                    consumeRetryContext = Object.freeze({
+                        error: normalizedError,
+                        attemptNumber: attemptNumber,
+                        retriesLeft: retriesLeft,
+                        retriesConsumed: retriesConsumed,
+                        retryDelay: retriesLeft > 0 ? delayTime : 0
+                    });
+                    return [
+                        4,
+                        options.shouldConsumeRetry(consumeRetryContext)
+                    ];
+                case 3:
+                    consumeRetry = _state.sent();
+                    effectiveDelay = consumeRetry && retriesLeft > 0 ? delayTime : 0;
+                    context1 = Object.freeze({
+                        error: normalizedError,
+                        attemptNumber: attemptNumber,
+                        retriesLeft: retriesLeft,
+                        retriesConsumed: retriesConsumed,
+                        retryDelay: effectiveDelay
+                    });
+                    return [
+                        4,
+                        options.onFailedAttempt(context1)
+                    ];
+                case 4:
+                    _state.sent();
+                    if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
+                        throw normalizedError;
+                    }
+                    remainingTime = calculateRemainingTime(startTime, maxRetryTime);
+                    if (remainingTime <= 0 || retriesLeft <= 0) {
+                        throw normalizedError;
+                    }
+                    if (_instanceof(normalizedError, TypeError) && !(0, _isNetworkError.default)(normalizedError)) {
+                        throw normalizedError;
+                    }
+                    return [
+                        4,
+                        options.shouldRetry(context1)
+                    ];
+                case 5:
+                    if (!_state.sent()) {
+                        throw normalizedError;
+                    }
+                    remainingTimeAfterShouldRetry = calculateRemainingTime(startTime, maxRetryTime);
+                    if (remainingTimeAfterShouldRetry <= 0) {
+                        throw normalizedError;
+                    }
+                    if (!consumeRetry) {
+                        ;
+                        (ref2 = options.signal) === null || ref2 === void 0 ? void 0 : ref2.throwIfAborted();
+                        return [
+                            2,
+                            false
+                        ];
+                    }
+                    finalDelay = Math.min(effectiveDelay, remainingTimeAfterShouldRetry);
+                    (ref = options.signal) === null || ref === void 0 ? void 0 : ref.throwIfAborted();
+                    return [
+                        4,
+                        delayForRetry(finalDelay, options)
+                    ];
+                case 6:
+                    _state.sent();
+                    (ref1 = options.signal) === null || ref1 === void 0 ? void 0 : ref1.throwIfAborted();
+                    return [
+                        2,
+                        true
+                    ];
+            }
+        });
+    });
+    return _onAttemptFailure.apply(this, arguments);
+}
+function pRetry(input) {
     return _pRetry.apply(this, arguments);
 }
 function _pRetry() {
-    _pRetry = _asyncToGenerator(function(input, options) {
+    _pRetry = _asyncToGenerator(function(input) {
+        var options, ref, _retries, _factor, _minTimeout, _maxTimeout, _maxRetryTime, _randomize, _onFailedAttempt, _shouldRetry, _shouldConsumeRetry, attemptNumber, retriesConsumed, startTime, ref1, ref2, result, error;
+        var _arguments = arguments;
         return __generator(this, function(_state) {
-            return [
-                2,
-                new Promise(function(resolve, reject) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
                     options = _objectSpread({}, options);
-                    var _onFailedAttempt;
-                    (_onFailedAttempt = (_options = options).onFailedAttempt) !== null && _onFailedAttempt !== void 0 ? _onFailedAttempt : _options.onFailedAttempt = function() {};
-                    var _shouldRetry;
-                    (_shouldRetry = (_options1 = options).shouldRetry) !== null && _shouldRetry !== void 0 ? _shouldRetry : _options1.shouldRetry = function() {
+                    validateRetries(options.retries);
+                    if (Object.hasOwn(options, "forever")) {
+                        throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+                    }
+                    (_retries = (_options = options).retries) !== null && _retries !== void 0 ? _retries : _options.retries = 10;
+                    (_factor = (_options1 = options).factor) !== null && _factor !== void 0 ? _factor : _options1.factor = 2;
+                    (_minTimeout = (_options2 = options).minTimeout) !== null && _minTimeout !== void 0 ? _minTimeout : _options2.minTimeout = 1000;
+                    (_maxTimeout = (_options3 = options).maxTimeout) !== null && _maxTimeout !== void 0 ? _maxTimeout : _options3.maxTimeout = Number.POSITIVE_INFINITY;
+                    (_maxRetryTime = (_options4 = options).maxRetryTime) !== null && _maxRetryTime !== void 0 ? _maxRetryTime : _options4.maxRetryTime = Number.POSITIVE_INFINITY;
+                    (_randomize = (_options5 = options).randomize) !== null && _randomize !== void 0 ? _randomize : _options5.randomize = false;
+                    (_onFailedAttempt = (_options6 = options).onFailedAttempt) !== null && _onFailedAttempt !== void 0 ? _onFailedAttempt : _options6.onFailedAttempt = function() {};
+                    (_shouldRetry = (_options7 = options).shouldRetry) !== null && _shouldRetry !== void 0 ? _shouldRetry : _options7.shouldRetry = function() {
                         return true;
                     };
-                    var _retries;
-                    (_retries = (_options2 = options).retries) !== null && _retries !== void 0 ? _retries : _options2.retries = 10;
-                    var operation = _retry.default.operation(options);
-                    var abortHandler = function() {
-                        var ref;
-                        operation.stop();
-                        reject((ref = options.signal) === null || ref === void 0 ? void 0 : ref.reason);
+                    (_shouldConsumeRetry = (_options8 = options).shouldConsumeRetry) !== null && _shouldConsumeRetry !== void 0 ? _shouldConsumeRetry : _options8.shouldConsumeRetry = function() {
+                        return true;
                     };
-                    if (options.signal && !options.signal.aborted) {
-                        options.signal.addEventListener("abort", abortHandler, {
-                            once: true
-                        });
+                    // Validate numeric options and normalize edge cases
+                    validateFunctionOption("onFailedAttempt", options.onFailedAttempt);
+                    validateFunctionOption("shouldRetry", options.shouldRetry);
+                    validateFunctionOption("shouldConsumeRetry", options.shouldConsumeRetry);
+                    validateNumberOption("factor", options.factor, {
+                        min: 0,
+                        allowInfinity: false
+                    });
+                    validateNumberOption("minTimeout", options.minTimeout, {
+                        min: 0,
+                        allowInfinity: false
+                    });
+                    validateNumberOption("maxTimeout", options.maxTimeout, {
+                        min: 0,
+                        allowInfinity: true
+                    });
+                    validateNumberOption("maxRetryTime", options.maxRetryTime, {
+                        min: 0,
+                        allowInfinity: true
+                    });
+                    // Treat non-positive factor as 1 to avoid zero backoff or negative behavior
+                    if (!(options.factor > 0)) {
+                        options.factor = 1;
                     }
-                    var cleanUp = function() {
-                        var ref;
-                        (ref = options.signal) === null || ref === void 0 ? void 0 : ref.removeEventListener("abort", abortHandler);
-                        operation.stop();
-                    };
-                    operation.attempt(function() {
-                        var _ref = _asyncToGenerator(function(attemptNumber) {
-                            var result, error, finalError;
-                            return __generator(this, function(_state) {
-                                switch(_state.label){
-                                    case 0:
-                                        _state.trys.push([
-                                            0,
-                                            2,
-                                            ,
-                                            8
-                                        ]);
-                                        return [
-                                            4,
-                                            input(attemptNumber)
-                                        ];
-                                    case 1:
-                                        result = _state.sent();
-                                        cleanUp();
-                                        resolve(result);
-                                        return [
-                                            3,
-                                            8
-                                        ];
-                                    case 2:
-                                        error = _state.sent();
-                                        _state.label = 3;
-                                    case 3:
-                                        _state.trys.push([
-                                            3,
-                                            6,
-                                            ,
-                                            7
-                                        ]);
-                                        if (!_instanceof(error, Error)) {
-                                            throw new TypeError('Non-error was thrown: "'.concat(error, '". You should only throw errors.'));
-                                        }
-                                        if (_instanceof(error, AbortError)) {
-                                            throw error.originalError;
-                                        }
-                                        if (_instanceof(error, TypeError) && !(0, _isNetworkError.default)(error)) {
-                                            throw error;
-                                        }
-                                        decorateErrorWithCounts(error, attemptNumber, options);
-                                        return [
-                                            4,
-                                            options.shouldRetry(error)
-                                        ];
-                                    case 4:
-                                        if (!_state.sent()) {
-                                            operation.stop();
-                                            reject(error);
-                                        }
-                                        return [
-                                            4,
-                                            options.onFailedAttempt(error)
-                                        ];
-                                    case 5:
-                                        _state.sent();
-                                        if (!operation.retry(error)) {
-                                            throw operation.mainError();
-                                        }
-                                        return [
-                                            3,
-                                            7
-                                        ];
-                                    case 6:
-                                        finalError = _state.sent();
-                                        decorateErrorWithCounts(finalError, attemptNumber, options);
-                                        cleanUp();
-                                        reject(finalError);
-                                        return [
-                                            3,
-                                            7
-                                        ];
-                                    case 7:
-                                        return [
-                                            3,
-                                            8
-                                        ];
-                                    case 8:
-                                        return [
-                                            2
-                                        ];
-                                }
-                            });
-                        });
-                        return function(attemptNumber) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }());
-                })
-            ];
+                    (ref = options.signal) === null || ref === void 0 ? void 0 : ref.throwIfAborted();
+                    attemptNumber = 0;
+                    retriesConsumed = 0;
+                    startTime = performance.now();
+                    _state.label = 1;
+                case 1:
+                    if (!(Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true)) return [
+                        3,
+                        7
+                    ];
+                    attemptNumber++;
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        6
+                    ]);
+                    (ref1 = options.signal) === null || ref1 === void 0 ? void 0 : ref1.throwIfAborted();
+                    return [
+                        4,
+                        input(attemptNumber)
+                    ];
+                case 3:
+                    result = _state.sent();
+                    (ref2 = options.signal) === null || ref2 === void 0 ? void 0 : ref2.throwIfAborted();
+                    return [
+                        2,
+                        result
+                    ];
+                case 4:
+                    error = _state.sent();
+                    return [
+                        4,
+                        onAttemptFailure({
+                            error: error,
+                            attemptNumber: attemptNumber,
+                            retriesConsumed: retriesConsumed,
+                            startTime: startTime,
+                            options: options
+                        })
+                    ];
+                case 5:
+                    if (_state.sent()) {
+                        retriesConsumed++;
+                    }
+                    return [
+                        3,
+                        6
+                    ];
+                case 6:
+                    return [
+                        3,
+                        1
+                    ];
+                case 7:
+                    // Should not reach here, but in case it does, throw an error
+                    throw new Error("Retry attempts exhausted without throwing an error.");
+            }
         });
     });
     return _pRetry.apply(this, arguments);
 }
+function makeRetriable(function_, options) {
+    return function() {
+        for(var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++){
+            arguments_[_key] = arguments[_key];
+        }
+        var _this = this;
+        return pRetry(function() {
+            return function_.apply(_this, arguments_);
+        }, options);
+    };
+}

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@common.js/p-retry",
-  "version": "6.2.1",
+  "version": "8.0.1",
   "description": "p-retry package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
   "funding": "https://github.com/sponsors/sindresorhus",
   "type": "commonjs",
-  "types": "./index.d.ts",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./index.js"
+  },
   "sideEffects": false,
   "engines": {
-    "node": ">=16.17"
+    "node": ">=22"
   },
   "scripts": {
     "test": "xo && ava && tsd"
@@ -19,16 +22,29 @@
     "index.d.ts"
   ],
   "dependencies": {
-    "@types/retry": "0.12.2",
-    "@common.js/is-network-error": "^1.0.0",
-    "retry": "^0.13.1"
+    "is-network-error": "npm:@common.js/is-network-error@1.3.3"
   },
   "devDependencies": {
-    "ava": "^5.3.1",
-    "delay": "^6.0.0",
-    "tsd": "^0.28.1",
-    "xo": "^0.56.0"
+    "ava": "^6.4.1",
+    "delay": "^7.0.0",
+    "execa": "^9.6.1",
+    "tsd": "^0.33.0",
+    "xo": "^1.2.3"
+  },
+  "xo": {
+    "rules": {
+      "no-await-in-loop": "off"
+    }
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
-  "main": "./index.js"
+  "commonjs": {
+    "source": {
+      "name": "p-retry",
+      "version": "8.0.0"
+    },
+    "transformRevision": 1,
+    "buildKey": "55b606486907007f9a9d30fe3a13db13a497a4d1f4947523f6ba48fb3e8335f1"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
 }