@common.js/p-retry 5.1.2

package/README.md

@@ -0,0 +1,5 @@
+# @common.js/p-retry
+
+The [p-retry](https://www.npmjs.com/package/p-retry) package exported as CommonJS modules.
+
+Exported from [p-retry@5.1.2](https://www.npmjs.com/package/p-retry/v/5.1.2) using https://github.com/etienne-martin/common.js.

package/index.d.ts

@@ -0,0 +1,116 @@
+import {OperationOptions} from 'retry';
+
+export class AbortError extends Error {
+	readonly name: 'AbortError';
+	readonly originalError: Error;
+
+	/**
+	Abort retrying and reject the promise.
+
+	@param message - An error message or a custom error.
+	*/
+	constructor(message: string | Error);
+}
+
+export interface FailedAttemptError extends Error {
+	readonly attemptNumber: number;
+	readonly retriesLeft: number;
+}
+
+export interface Options extends OperationOptions {
+	/**
+	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.
+
+	The `onFailedAttempt` function can return a promise. For example, to add a [delay](https://github.com/sindresorhus/delay):
+
+	```
+	import pRetry from 'p-retry';
+	import delay from 'delay';
+
+	const run = async () => { ... };
+
+	const result = await pRetry(run, {
+		onFailedAttempt: async error => {
+			console.log('Waiting for 1 second before retrying');
+			await delay(1000);
+		}
+	});
+	```
+
+	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>;
+
+	/**
+	You can abort retrying using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+
+	When `AbortController.abort(reason)` is called, the promise will be rejected with `reason` as the error message.
+
+	*Requires Node.js 16 or later.*
+
+	```
+	import pRetry from 'p-retry';
+
+	const run = async () => { … };
+	const controller = new AbortController();
+
+	cancelButton.addEventListener('click', () => {
+		controller.abort('User clicked cancel button');
+	});
+
+	try {
+		await pRetry(run, {signal: controller.signal});
+	} catch (error) {
+		console.log(error.message);
+		//=> 'User clicked cancel button'
+	}
+	```
+	*/
+	readonly signal?: AbortSignal;
+}
+
+/**
+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)
+
+@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.
+
+@example
+```
+import pRetry, {AbortError} from 'p-retry';
+import fetch from 'node-fetch';
+
+const run = async () => {
+	const response = await fetch('https://sindresorhus.com/unicorn');
+
+	// Abort retrying if the resource doesn't exist
+	if (response.status === 404) {
+		throw new AbortError(response.statusText);
+	}
+
+	return response.blob();
+};
+
+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,
+	options?: Options
+): Promise<T>;

package/index.js

@@ -0,0 +1,481 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AbortError: function() {
+        return AbortError;
+    },
+    default: function() {
+        return pRetry;
+    }
+});
+var _retry = /*#__PURE__*/ _interopRequireDefault(require("retry"));
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return _wrapNativeSuper(Class);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var networkErrorMsgs = new Set([
+    "Failed to fetch",
+    "NetworkError when attempting to fetch resource.",
+    "The Internet connection appears to be offline.",
+    "Network request failed",
+    "fetch failed"
+]);
+var AbortError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(AbortError, Error1);
+    var _super = _createSuper(AbortError);
+    function AbortError(message) {
+        _classCallCheck(this, AbortError);
+        var _this;
+        _this = _super.call(this);
+        if (_instanceof(message, Error)) {
+            _this.originalError = message;
+            message = message.message;
+        } else {
+            _this.originalError = new Error(message);
+            _this.originalError.stack = _this.stack;
+        }
+        _this.name = "AbortError";
+        _this.message = message;
+        return _this;
+    }
+    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;
+};
+var isNetworkError = function(errorMessage) {
+    return networkErrorMsgs.has(errorMessage);
+};
+var getDOMException = function(errorMessage) {
+    return globalThis.DOMException === undefined ? new Error(errorMessage) : new DOMException(errorMessage);
+};
+function pRetry(input, options) {
+    return _pRetry.apply(this, arguments);
+}
+function _pRetry() {
+    _pRetry = _asyncToGenerator(function(input, options) {
+        return __generator(this, function(_state) {
+            return [
+                2,
+                new Promise(function(resolve, reject) {
+                    options = _objectSpread({
+                        onFailedAttempt: function onFailedAttempt() {},
+                        retries: 10
+                    }, options);
+                    var operation = _retry.default.operation(options);
+                    operation.attempt(function() {
+                        var _ref = _asyncToGenerator(function(attemptNumber) {
+                            var error, error1;
+                            return __generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        _state.trys.push([
+                                            0,
+                                            2,
+                                            ,
+                                            10
+                                        ]);
+                                        return [
+                                            4,
+                                            input(attemptNumber)
+                                        ];
+                                    case 1:
+                                        resolve.apply(void 0, [
+                                            _state.sent()
+                                        ]);
+                                        return [
+                                            3,
+                                            10
+                                        ];
+                                    case 2:
+                                        error = _state.sent();
+                                        if (!_instanceof(error, Error)) {
+                                            reject(new TypeError('Non-error was thrown: "'.concat(error, '". You should only throw errors.')));
+                                            return [
+                                                2
+                                            ];
+                                        }
+                                        if (!_instanceof(error, AbortError)) return [
+                                            3,
+                                            3
+                                        ];
+                                        operation.stop();
+                                        reject(error.originalError);
+                                        return [
+                                            3,
+                                            9
+                                        ];
+                                    case 3:
+                                        if (!(_instanceof(error, TypeError) && !isNetworkError(error.message))) return [
+                                            3,
+                                            4
+                                        ];
+                                        operation.stop();
+                                        reject(error);
+                                        return [
+                                            3,
+                                            9
+                                        ];
+                                    case 4:
+                                        decorateErrorWithCounts(error, attemptNumber, options);
+                                        _state.label = 5;
+                                    case 5:
+                                        _state.trys.push([
+                                            5,
+                                            7,
+                                            ,
+                                            8
+                                        ]);
+                                        return [
+                                            4,
+                                            options.onFailedAttempt(error)
+                                        ];
+                                    case 6:
+                                        _state.sent();
+                                        return [
+                                            3,
+                                            8
+                                        ];
+                                    case 7:
+                                        error1 = _state.sent();
+                                        reject(error1);
+                                        return [
+                                            2
+                                        ];
+                                    case 8:
+                                        if (!operation.retry(error)) {
+                                            reject(operation.mainError());
+                                        }
+                                        _state.label = 9;
+                                    case 9:
+                                        return [
+                                            3,
+                                            10
+                                        ];
+                                    case 10:
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        });
+                        return function(attemptNumber) {
+                            return _ref.apply(this, arguments);
+                        };
+                    }());
+                    if (options.signal && !options.signal.aborted) {
+                        options.signal.addEventListener("abort", function() {
+                            operation.stop();
+                            var reason = options.signal.reason === undefined ? getDOMException("The operation was aborted.") : options.signal.reason;
+                            reject(_instanceof(reason, Error) ? reason : getDOMException(reason));
+                        }, {
+                            once: true
+                        });
+                    }
+                })
+            ];
+        });
+    });
+    return _pRetry.apply(this, arguments);
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@common.js/p-retry",
+  "version": "5.1.2",
+  "description": "p-retry package exported as CommonJS modules",
+  "license": "MIT",
+  "repository": "etienne-martin/common.js",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "type": "commonjs",
+  "engines": {
+    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "dependencies": {
+    "@types/retry": "0.12.1",
+    "retry": "^0.13.1"
+  },
+  "devDependencies": {
+    "ava": "^4.1.0",
+    "delay": "^5.0.0",
+    "tsd": "^0.19.1",
+    "xo": "^0.48.0"
+  },
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "main": "./index.js"
+}