FM / p-retry

/var/www/flurhymez/node_modules/p-retry/

/var/www/flurhymez/node_modules/p-retry

Name	Size	Mode	Actions
index.d.ts	3412	0644	edit dl rm
index.js	2077	0644	edit dl rm
license	1109	0644	edit dl rm
package.json	1852	0644	edit dl rm
readme.md	3611	0644	edit dl rm

Edit: /var/www/flurhymez/node_modules/p-retry/index.d.ts (3412B)

import {OperationOptions} from 'retry';

declare class AbortErrorClass extends Error {
	readonly name: 'AbortError';
	readonly originalError: Error;

/**
	Abort retrying and reject the promise.

@param message - Error message or custom error.
	*/
	constructor(message: string | Error);
}

declare namespace pRetry {
	interface FailedAttemptError extends Error {
		readonly attemptNumber: number;
		readonly retriesLeft: number;
	}

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 = require('p-retry');
		import delay = require('delay');

const run = async () => { ... };

(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>;
	}

type AbortError = AbortErrorClass;
}

declare const pRetry: {
	/**
	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 = require('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 pRetry.AbortError(response.statusText);
		}

return response.blob();
	};

(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);
	})();
	```
	*/
	<T>(
		input: (attemptCount: number) => PromiseLike<T> | T,
		options?: pRetry.Options
	): Promise<T>;

AbortError: typeof AbortErrorClass;

// TODO: remove this in the next major version
	default: typeof pRetry;
};

export = pRetry;

cmd: