@common.js/p-timeout 5.1.0 → 6.0.0

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@5.1.0](https://www.npmjs.com/package/p-timeout/v/5.1.0) using https://github.com/etienne-martin/common.js.
+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.

package/index.d.ts

@@ -1,18 +1,54 @@
-/* eslint-disable import/export */
-
 export class TimeoutError extends Error {
 	readonly name: 'TimeoutError';
 	constructor(message?: string);
 }
 
-export interface ClearablePromise<T> extends Promise<T>{
+export interface ClearablePromise<T> extends Promise<T> {
 	/**
 	Clear the timeout.
 	*/
 	clear: () => void;
 }
 
-export type Options = {
+export type Options<ReturnType> = {
+	/**
+	Milliseconds before timing out.
+
+	Passing `Infinity` will cause it to never time out.
+	*/
+	milliseconds: number;
+
+	/**
+	Do something other than rejecting with an error on timeout.
+
+	You could for example retry:
+
+	@example
+	```
+	import {setTimeout} from 'node:timers/promises';
+	import pTimeout from 'p-timeout';
+
+	const delayedPromise = () => setTimeout(200);
+
+	await pTimeout(delayedPromise(), {
+		milliseconds: 50,
+		fallback: () => {
+			return pTimeout(delayedPromise(), {
+				milliseconds: 300
+			});
+		},
+	});
+	```
+	*/
+	fallback?: () => ReturnType | Promise<ReturnType>;
+
+	/**
+	Specify a custom error message or error.
+
+	If you do a custom error, it's recommended to sub-class `pTimeout.TimeoutError`.
+	*/
+	message?: string | Error;
+
 	/**
 	Custom implementations for the `setTimeout` and `clearTimeout` functions.
 
@@ -29,7 +65,8 @@ export type Options = {
 	sinon.useFakeTimers();
 
 	// Use `pTimeout` without being affected by `sinon.useFakeTimers()`:
-	await pTimeout(doSomething(), 2000, undefined, {
+	await pTimeout(doSomething(), {
+		milliseconds: 2000,
 		customTimers: {
 			setTimeout: originalSetTimeout,
 			clearTimeout: originalClearTimeout
@@ -38,8 +75,8 @@ export type Options = {
 	```
 	*/
 	readonly customTimers?: {
-		setTimeout: typeof global.setTimeout;
-		clearTimeout: typeof global.clearTimeout;
+		setTimeout: typeof globalThis.setTimeout;
+		clearTimeout: typeof globalThis.clearTimeout;
 	};
 
 	/**
@@ -60,7 +97,8 @@ export type Options = {
 		abortController.abort();
 	}, 100);
 
-	await pTimeout(delayedPromise, 2000, undefined, {
+	await pTimeout(delayedPromise, {
+		milliseconds: 2000,
 		signal: abortController.signal
 	});
 	```
@@ -74,53 +112,24 @@ Timeout a promise after a specified amount of time.
 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.
 
 @param input - Promise to decorate.
-@param milliseconds - Milliseconds before timing out.
-@param message - Specify a custom error message or error. If you do a custom error, it's recommended to sub-class `pTimeout.TimeoutError`. Default: `'Promise timed out after 50 milliseconds'`.
-@returns A decorated `input` that times out after `milliseconds` time. It has a `.clear()` method that clears the timeout.
-
-@example
-```
-import {setTimeout} from 'timers/promises';
-import pTimeout from 'p-timeout';
-
-const delayedPromise = setTimeout(200);
-
-await pTimeout(delayedPromise, 50);
-//=> [TimeoutError: Promise timed out after 50 milliseconds]
-```
-*/
-export default function pTimeout<ValueType>(
-	input: PromiseLike<ValueType>,
-	milliseconds: number,
-	message?: string | Error,
-	options?: Options
-): ClearablePromise<ValueType>;
-
-/**
-Timeout a promise after a specified amount of time.
-
-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.
-
-@param input - Promise to decorate.
-@param milliseconds - Milliseconds before timing out. Passing `Infinity` will cause it to never time out.
-@param fallback - Do something other than rejecting with an error on timeout. You could for example retry.
 @returns A decorated `input` that times out after `milliseconds` time. It has a `.clear()` method that clears the timeout.
 
 @example
 ```
-import {setTimeout} from 'timers/promises';
+import {setTimeout} from 'node:timers/promises';
 import pTimeout from 'p-timeout';
 
 const delayedPromise = () => setTimeout(200);
 
-await pTimeout(delayedPromise(), 50, () => {
-	return pTimeout(delayedPromise(), 300);
+await pTimeout(delayedPromise(), {
+	milliseconds: 50,
+	fallback: () => {
+		return pTimeout(delayedPromise(), 300);
+	}
 });
 ```
 */
-export default function pTimeout<ValueType, ReturnType>(
+export default function pTimeout<ValueType, ReturnType = ValueType>(
 	input: PromiseLike<ValueType>,
-	milliseconds: number,
-	fallback: () => ReturnType | Promise<ReturnType>,
-	options?: Options
+	options: Options<ReturnType>
 ): ClearablePromise<ValueType | ReturnType>;

package/index.js

@@ -87,19 +87,6 @@ function _construct(Parent, args, Class) {
     }
     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);
@@ -129,21 +116,6 @@ function _instanceof(left, right) {
 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;
@@ -344,7 +316,11 @@ TODO: Remove below function and just 'reject(signal.reason)' when targeting Node
     var reason = signal.reason === undefined ? getDOMException("This operation was aborted.") : signal.reason;
     return _instanceof(reason, Error) ? reason : getDOMException(reason);
 };
-function pTimeout(promise, milliseconds, fallback, options) {
+function pTimeout(promise, options) {
+    var milliseconds = options.milliseconds, fallback = options.fallback, message = options.message, _customTimers = options.customTimers, customTimers = _customTimers === void 0 ? {
+        setTimeout: setTimeout,
+        clearTimeout: clearTimeout
+    } : _customTimers;
     var timer;
     var cancelablePromise = new Promise(function(resolve, reject) {
         if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
@@ -354,12 +330,6 @@ function pTimeout(promise, milliseconds, fallback, options) {
             resolve(promise);
             return;
         }
-        options = _objectSpread({
-            customTimers: {
-                setTimeout: setTimeout,
-                clearTimeout: clearTimeout
-            }
-        }, options);
         if (options.signal) {
             var signal = options.signal;
             if (signal.aborted) {
@@ -369,8 +339,8 @@ function pTimeout(promise, milliseconds, fallback, options) {
                 reject(getAbortedReason(signal));
             });
         }
-        timer = options.customTimers.setTimeout.call(undefined, function() {
-            if (typeof fallback === "function") {
+        timer = customTimers.setTimeout.call(undefined, function() {
+            if (fallback) {
                 try {
                     resolve(fallback());
                 } catch (error) {
@@ -378,8 +348,8 @@ function pTimeout(promise, milliseconds, fallback, options) {
                 }
                 return;
             }
-            var message = typeof fallback === "string" ? fallback : "Promise timed out after ".concat(milliseconds, " milliseconds");
-            var timeoutError = _instanceof(fallback, Error) ? fallback : new TimeoutError(message);
+            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();
             }
@@ -416,7 +386,7 @@ function pTimeout(promise, milliseconds, fallback, options) {
                             4
                         ];
                     case 3:
-                        options.customTimers.clearTimeout.call(undefined, timer);
+                        customTimers.clearTimeout.call(undefined, timer);
                         return [
                             7
                         ];
@@ -429,7 +399,7 @@ function pTimeout(promise, milliseconds, fallback, options) {
         })();
     });
     cancelablePromise.clear = function() {
-        clearTimeout(timer);
+        customTimers.clearTimeout.call(undefined, timer);
         timer = undefined;
     };
     return cancelablePromise;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@common.js/p-timeout",
-  "version": "5.1.0",
+  "version": "6.0.0",
   "description": "Timeout a promise after a specified amount of time",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
   "funding": "https://github.com/sponsors/sindresorhus",
   "type": "commonjs",
+  "types": "./index.d.ts",
   "engines": {
-    "node": ">=12"
+    "node": ">=14.16"
   },
   "scripts": {
     "test": "xo && ava && tsd"
@@ -17,13 +18,13 @@
     "index.d.ts"
   ],
   "devDependencies": {
-    "ava": "^3.15.0",
+    "ava": "^4.3.1",
     "delay": "^5.0.0",
     "in-range": "^3.0.0",
-    "p-cancelable": "^2.1.0",
-    "time-span": "^4.0.0",
-    "tsd": "^0.14.0",
-    "xo": "^0.38.2"
+    "p-cancelable": "^4.0.1",
+    "time-span": "^5.1.0",
+    "tsd": "^0.22.0",
+    "xo": "^0.51.0"
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
   "dependencies": {},

package/readme.md

@@ -4,26 +4,27 @@
 
 ## Install
 
-```
-$ npm install p-timeout
+```sh
+npm install p-timeout
 ```
 
 ## Usage
 
 ```js
-import {setTimeout} from 'timers/promises';
+import {setTimeout} from 'node:timers/promises';
 import pTimeout from 'p-timeout';
 
 const delayedPromise = setTimeout(200);
 
-await pTimeout(delayedPromise, 50);
+await pTimeout(delayedPromise, {
+	milliseconds: 50,
+});
 //=> [TimeoutError: Promise timed out after 50 milliseconds]
 ```
 
 ## API
 
-### pTimeout(input, milliseconds, message?, options?)
-### pTimeout(input, milliseconds, fallback?, options?)
+### pTimeout(input, options)
 
 Returns a decorated `input` that times out after `milliseconds` time. It has a `.clear()` method that clears the timeout.
 
@@ -35,7 +36,11 @@ Type: `Promise`
 
 Promise to decorate.
 
-#### milliseconds
+#### options
+
+Type: `object`
+
+##### milliseconds
 
 Type: `number`
 
@@ -43,7 +48,7 @@ Milliseconds before timing out.
 
 Passing `Infinity` will cause it to never time out.
 
-#### message
+##### message
 
 Type: `string | Error`\
 Default: `'Promise timed out after 50 milliseconds'`
@@ -52,7 +57,7 @@ Specify a custom error message or error.
 
 If you do a custom error, it's recommended to sub-class `pTimeout.TimeoutError`.
 
-#### fallback
+##### fallback
 
 Type: `Function`
 
@@ -61,20 +66,19 @@ Do something other than rejecting with an error on timeout.
 You could for example retry:
 
 ```js
-import {setTimeout} from 'timers/promises';
+import {setTimeout} from 'node:timers/promises';
 import pTimeout from 'p-timeout';
 
 const delayedPromise = () => setTimeout(200);
 
-await pTimeout(delayedPromise(), 50, () => {
-	return pTimeout(delayedPromise(), 300);
+await pTimeout(delayedPromise(), {
+	milliseconds: 50,
+	fallback: () => {
+		return pTimeout(delayedPromise(), 300);
+	},
 });
 ```
 
-#### options
-
-Type: `object`
-
 ##### customTimers
 
 Type: `object` with function properties `setTimeout` and `clearTimeout`
@@ -86,7 +90,7 @@ Useful for testing purposes, in particular to work around [`sinon.useFakeTimers(
 Example:
 
 ```js
-import {setTimeout} from 'timers/promises';
+import {setTimeout} from 'node:timers/promises';
 import pTimeout from 'p-timeout';
 
 const originalSetTimeout = setTimeout;
@@ -95,7 +99,8 @@ const originalClearTimeout = clearTimeout;
 sinon.useFakeTimers();
 
 // Use `pTimeout` without being affected by `sinon.useFakeTimers()`:
-await pTimeout(doSomething(), 2000, undefined, {
+await pTimeout(doSomething(), {
+	milliseconds: 2000,
 	customTimers: {
 		setTimeout: originalSetTimeout,
 		clearTimeout: originalClearTimeout
@@ -123,7 +128,8 @@ setTimeout(() => {
 	abortController.abort();
 }, 100);
 
-await pTimeout(delayedPromise, 2000, undefined, {
+await pTimeout(delayedPromise, {
+	milliseconds: 2000,
 	signal: abortController.signal
 });
 ```