@zhengxs/wechaty-plugin-assistant
Version:
83 lines (72 loc) • 2.82 kB
TypeScript
/// <reference types="node" />
export declare class TimeoutError extends Error {
readonly name = "TimeoutError";
constructor(message?: string);
}
/**
An error to be thrown when the request is aborted by AbortController.
DOMException is thrown instead of this Error when DOMException is available.
*/
export declare class AbortError extends Error {
readonly name = "TimeoutError";
constructor(message?: string);
}
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.
*/
fallback?: () => ReturnType | Promise<ReturnType>;
/**
Specify a custom error message or error to throw when it times out:
- `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`:
*/
message?: string | Error | false;
/**
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/).
*/
readonly customTimers?: {
setTimeout: typeof globalThis.setTimeout;
clearTimeout: typeof globalThis.clearTimeout;
};
/**
You can abort the promise using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
_Requires Node.js 16 or later._
*/
signal?: globalThis.AbortSignal;
};
export type ClearablePromise<T> = {
/**
Clear the timeout.
*/
clear: () => void;
} & Promise<T>;
/**
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.
@returns A decorated `input` that times out after `milliseconds` time. It has a `.clear()` method that clears the timeout.
@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});
}
});
```
*/
export default function pTimeout<ValueType, ReturnType = ValueType>(promise: PromiseLike<ValueType>, options: Options<ReturnType> & {
message: false;
}): ClearablePromise<ValueType | ReturnType | undefined>;