@common.js/p-timeout 6.0.0 → 6.1.1

package/README.md

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

package/index.d.ts

@@ -43,11 +43,23 @@ export type Options<ReturnType> = {
 	fallback?: () => ReturnType | Promise<ReturnType>;
 
 	/**
-	Specify a custom error message or error.
+	Specify a custom error message or error to throw when it times out:
 
-	If you do a custom error, it's recommended to sub-class `pTimeout.TimeoutError`.
+	- `message: 'too slow'` will throw `TimeoutError('too slow')`
+	- `message: new MyCustomError('it’s over 9000')` will throw the same error instance
+	- `message: false` will make the promise resolve with `undefined` instead of rejecting
+
+	If you do a custom error, it's recommended to sub-class `TimeoutError`:
+
+	```
+	import {TimeoutError} from 'p-timeout';
+
+	class MyCustomError extends TimeoutError {
+		name = "MyCustomError";
+	}
+	```
 	*/
-	message?: string | Error;
+	message?: string | Error | false;
 
 	/**
 	Custom implementations for the `setTimeout` and `clearTimeout` functions.
@@ -124,11 +136,15 @@ const delayedPromise = () => setTimeout(200);
 await pTimeout(delayedPromise(), {
 	milliseconds: 50,
 	fallback: () => {
-		return pTimeout(delayedPromise(), 300);
+		return pTimeout(delayedPromise(), {milliseconds: 300});
 	}
 });
 ```
 */
+export default function pTimeout<ValueType, ReturnType = ValueType>(
+	input: PromiseLike<ValueType>,
+	options: Options<ReturnType> & {message: false}
+): ClearablePromise<ValueType | ReturnType | undefined>;
 export default function pTimeout<ValueType, ReturnType = ValueType>(
 	input: PromiseLike<ValueType>,
 	options: Options<ReturnType>

package/index.js

@@ -339,6 +339,8 @@ function pTimeout(promise, options) {
                 reject(getAbortedReason(signal));
             });
         }
+        // We create the error outside of `setTimeout` to preserve the stack trace.
+        var timeoutError = new TimeoutError();
         timer = customTimers.setTimeout.call(undefined, function() {
             if (fallback) {
                 try {
@@ -348,12 +350,17 @@ function pTimeout(promise, options) {
                 }
                 return;
             }
-            var errorMessage = typeof message === "string" ? message : "Promise timed out after ".concat(milliseconds, " milliseconds");
-            var timeoutError = _instanceof(message, Error) ? message : new TimeoutError(errorMessage);
             if (typeof promise.cancel === "function") {
                 promise.cancel();
             }
-            reject(timeoutError);
+            if (message === false) {
+                resolve();
+            } else if (_instanceof(message, Error)) {
+                reject(message);
+            } else {
+                timeoutError.message = message !== null && message !== void 0 ? message : "Promise timed out after ".concat(milliseconds, " milliseconds");
+                reject(timeoutError);
+            }
         }, milliseconds);
         _asyncToGenerator(function() {
             var error;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@common.js/p-timeout",
-  "version": "6.0.0",
-  "description": "Timeout a promise after a specified amount of time",
+  "version": "6.1.1",
+  "description": "p-timeout package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
   "funding": "https://github.com/sponsors/sindresorhus",

package/readme.md

@@ -1,146 +0,0 @@
-# p-timeout
-
-> Timeout a promise after a specified amount of time
-
-## Install
-
-```sh
-npm install p-timeout
-```
-
-## Usage
-
-```js
-import {setTimeout} from 'node:timers/promises';
-import pTimeout from 'p-timeout';
-
-const delayedPromise = setTimeout(200);
-
-await pTimeout(delayedPromise, {
-	milliseconds: 50,
-});
-//=> [TimeoutError: Promise timed out after 50 milliseconds]
-```
-
-## API
-
-### pTimeout(input, options)
-
-Returns a decorated `input` that times out after `milliseconds` time. It has a `.clear()` method that clears the timeout.
-
-If you pass in a cancelable promise, specifically a promise with a `.cancel()` method, that method will be called when the `pTimeout` promise times out.
-
-#### input
-
-Type: `Promise`
-
-Promise to decorate.
-
-#### options
-
-Type: `object`
-
-##### milliseconds
-
-Type: `number`
-
-Milliseconds before timing out.
-
-Passing `Infinity` will cause it to never time out.
-
-##### message
-
-Type: `string | Error`\
-Default: `'Promise timed out after 50 milliseconds'`
-
-Specify a custom error message or error.
-
-If you do a custom error, it's recommended to sub-class `pTimeout.TimeoutError`.
-
-##### fallback
-
-Type: `Function`
-
-Do something other than rejecting with an error on timeout.
-
-You could for example retry:
-
-```js
-import {setTimeout} from 'node:timers/promises';
-import pTimeout from 'p-timeout';
-
-const delayedPromise = () => setTimeout(200);
-
-await pTimeout(delayedPromise(), {
-	milliseconds: 50,
-	fallback: () => {
-		return pTimeout(delayedPromise(), 300);
-	},
-});
-```
-
-##### customTimers
-
-Type: `object` with function properties `setTimeout` and `clearTimeout`
-
-Custom implementations for the `setTimeout` and `clearTimeout` functions.
-
-Useful for testing purposes, in particular to work around [`sinon.useFakeTimers()`](https://sinonjs.org/releases/latest/fake-timers/).
-
-Example:
-
-```js
-import {setTimeout} from 'node:timers/promises';
-import pTimeout from 'p-timeout';
-
-const originalSetTimeout = setTimeout;
-const originalClearTimeout = clearTimeout;
-
-sinon.useFakeTimers();
-
-// Use `pTimeout` without being affected by `sinon.useFakeTimers()`:
-await pTimeout(doSomething(), {
-	milliseconds: 2000,
-	customTimers: {
-		setTimeout: originalSetTimeout,
-		clearTimeout: originalClearTimeout
-	}
-});
-```
-
-#### signal
-
-Type: [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)
-
-You can abort the promise using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
-
-*Requires Node.js 16 or later.*
-
-```js
-import pTimeout from 'p-timeout';
-import delay from 'delay';
-
-const delayedPromise = delay(3000);
-
-const abortController = new AbortController();
-
-setTimeout(() => {
-	abortController.abort();
-}, 100);
-
-await pTimeout(delayedPromise, {
-	milliseconds: 2000,
-	signal: abortController.signal
-});
-```
-
-### TimeoutError
-
-Exposed for instance checking and sub-classing.
-
-## Related
-
-- [delay](https://github.com/sindresorhus/delay) - Delay a promise a specified amount of time
-- [p-min-delay](https://github.com/sindresorhus/p-min-delay) - Delay a promise a minimum amount of time
-- [p-retry](https://github.com/sindresorhus/p-retry) - Retry a promise-returning function
-- [More…](https://github.com/sindresorhus/promise-fun)