@common.js/p-retry 6.1.0 → 6.2.0

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.1.0](https://www.npmjs.com/package/p-retry/v/6.1.0) using https://github.com/etienne-martin/common.js.
+Exported from [p-retry@6.2.0](https://www.npmjs.com/package/p-retry/v/6.2.0) using https://github.com/etienne-martin/common.js.

package/index.d.ts

@@ -41,6 +41,28 @@ export type Options = {
 	*/
 	readonly onFailedAttempt?: (error: FailedAttemptError) => void | Promise<void>;
 
+	/**
+	Decide if a retry should occur based on the error. Returning true triggers a retry, false aborts with the error.
+
+	It is not called for `TypeError` (except network errors) and `AbortError`.
+
+	@param error - The error thrown by the input function.
+
+	@example
+	```
+	import pRetry from 'p-retry';
+
+	const run = async () => { … };
+
+	const result = await pRetry(run, {
+		shouldRetry: error => !(error instanceof CustomError);
+	});
+	```
+
+	In the example above, the operation will be retried unless the error is an instance of `CustomError`.
+	*/
+	readonly shouldRetry?: (error: FailedAttemptError) => boolean | Promise<boolean>;
+
 	/**
 	You can abort retrying using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
 

package/index.js

@@ -349,7 +349,10 @@ function _pRetry() {
                 new Promise(function(resolve, reject) {
                     options = _objectSpread({
                         onFailedAttempt: function onFailedAttempt() {},
-                        retries: 10
+                        retries: 10,
+                        shouldRetry: function() {
+                            return true;
+                        }
                     }, options);
                     var operation = _retry.default.operation(options);
                     var abortHandler = function() {
@@ -377,7 +380,7 @@ function _pRetry() {
                                             0,
                                             2,
                                             ,
-                                            7
+                                            8
                                         ]);
                                         return [
                                             4,
@@ -389,7 +392,7 @@ function _pRetry() {
                                         resolve(result);
                                         return [
                                             3,
-                                            7
+                                            8
                                         ];
                                     case 2:
                                         error = _state.sent();
@@ -397,9 +400,9 @@ function _pRetry() {
                                     case 3:
                                         _state.trys.push([
                                             3,
-                                            5,
+                                            6,
                                             ,
-                                            6
+                                            7
                                         ]);
                                         if (!_instanceof(error, Error)) {
                                             throw new TypeError('Non-error was thrown: "'.concat(error, '". You should only throw errors.'));
@@ -410,34 +413,44 @@ function _pRetry() {
                                         if (_instanceof(error, TypeError) && !(0, _isNetworkError.default)(error)) {
                                             throw error;
                                         }
+                                        decorateErrorWithCounts(error, attemptNumber, options);
                                         return [
                                             4,
-                                            options.onFailedAttempt(decorateErrorWithCounts(error, attemptNumber, options))
+                                            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,
-                                            6
+                                            7
                                         ];
-                                    case 5:
+                                    case 6:
                                         finalError = _state.sent();
                                         decorateErrorWithCounts(finalError, attemptNumber, options);
                                         cleanUp();
                                         reject(finalError);
                                         return [
                                             3,
-                                            6
+                                            7
                                         ];
-                                    case 6:
+                                    case 7:
                                         return [
                                             3,
-                                            7
+                                            8
                                         ];
-                                    case 7:
+                                    case 8:
                                         return [
                                             2
                                         ];

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@common.js/p-retry",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "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",
+  "sideEffects": false,
   "engines": {
     "node": ">=16.17"
   },