127 lines
4.6 KiB
TypeScript
127 lines
4.6 KiB
TypeScript
/**
|
|
* Options for {@link waitForCondition }
|
|
*/
|
|
export type WaitForConditionOptions = {
|
|
waitMs?: number | undefined;
|
|
intervalMs?: number | undefined;
|
|
logger?: {
|
|
debug: (...args: any[]) => void;
|
|
} | undefined;
|
|
error?: string | Error | undefined;
|
|
};
|
|
/**
|
|
* Options for {@link longSleep }
|
|
*/
|
|
export type LongSleepOptions = {
|
|
thresholdMs?: number | undefined;
|
|
intervalMs?: number | undefined;
|
|
progressCb?: ProgressCallback | null | undefined;
|
|
};
|
|
/**
|
|
* Parameter provided to a {@link ProgressCallback }
|
|
*/
|
|
export type Progress = {
|
|
elapsedMs: number;
|
|
timeLeft: number;
|
|
progress: number;
|
|
};
|
|
/**
|
|
* Progress callback for {@link longSleep }
|
|
*/
|
|
export type ProgressCallback = (progress: Progress) => void;
|
|
/**
|
|
* An async/await version of setTimeout
|
|
* @param {number} ms
|
|
* @returns {Promise<void>}
|
|
*/
|
|
export function sleep(ms: number): Promise<void>;
|
|
/**
|
|
* An async/await way of running a method until it doesn't throw an error
|
|
* @template [T=any]
|
|
* @param {number} times
|
|
* @param {(...args: any[]) => Promise<T>} fn
|
|
* @param {...any} args
|
|
* @returns {Promise<T?>}
|
|
*/
|
|
export function retry<T = any>(times: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
|
|
/**
|
|
* Export async functions (Promises) and import this with your ES5 code to use
|
|
* it with Node.
|
|
* @template [R=any]
|
|
* @param {any} promisey
|
|
* @param {(err: any, value?: R) => void} cb
|
|
* @returns {Promise<R>}
|
|
*/
|
|
export function nodeify<R = any>(promisey: any, cb: (err: any, value?: R | undefined) => void): Promise<R>;
|
|
/**
|
|
* Node-ify an entire object of `Promise`-returning functions
|
|
* @param {Record<string,(...args: any[]) => any>} promiseyMap
|
|
* @returns {Record<string,(...args: any[])=>void>}
|
|
*/
|
|
export function nodeifyAll(promiseyMap: Record<string, (...args: any[]) => any>): Record<string, (...args: any[]) => void>;
|
|
/**
|
|
* You can also use `retryInterval` to add a sleep in between retries. This can
|
|
* be useful if you want to throttle how fast we retry.
|
|
* @template [T=any]
|
|
* @param {number} times
|
|
* @param {number} sleepMs
|
|
* @param {(...args: any[]) => Promise<T>} fn
|
|
* @param {...any} args
|
|
* @returns {Promise<T?>}
|
|
*/
|
|
export function retryInterval<T = any>(times: number, sleepMs: number, fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T | null>;
|
|
/**
|
|
* @param {(...args: any[]) => any|Promise<any>} fn
|
|
* @param {...any} args
|
|
*/
|
|
export function asyncify(fn: (...args: any[]) => any | Promise<any>, ...args: any[]): void;
|
|
export const parallel: typeof B.all;
|
|
/**
|
|
* Similar to `Array.prototype.map`; runs in serial
|
|
* @param {any[]} coll
|
|
* @param {(value: any) => any|Promise<any>} mapper
|
|
* @returns {Promise<any[]>}
|
|
*/
|
|
export function asyncmap(coll: any[], mapper: (value: any) => any | Promise<any>, runInParallel?: boolean): Promise<any[]>;
|
|
/**
|
|
* Similar to `Array.prototype.filter`
|
|
* @param {any[]} coll
|
|
* @param {(value: any) => any|Promise<any>} filter
|
|
* @param {boolean} runInParallel
|
|
* @returns {Promise<any[]>}
|
|
*/
|
|
export function asyncfilter(coll: any[], filter: (value: any) => any | Promise<any>, runInParallel?: boolean): Promise<any[]>;
|
|
/**
|
|
* Takes a condition (a function returning a boolean or boolean promise), and
|
|
* waits until the condition is true.
|
|
*
|
|
* Throws a `/Condition unmet/` error if the condition has not been satisfied
|
|
* within the allocated time, unless an error is provided in the options, as the
|
|
* `error` property, which is either thrown itself, or used as the message.
|
|
*
|
|
* The condition result is returned if it is not falsy. If the condition throws an
|
|
* error then this exception will be immediately passed through.
|
|
*
|
|
* The default options are: `{ waitMs: 5000, intervalMs: 500 }`
|
|
* @template T
|
|
* @param {() => Promise<T>|T} condFn
|
|
* @param {WaitForConditionOptions} [options]
|
|
* @returns {Promise<T>}
|
|
*/
|
|
export function waitForCondition<T>(condFn: () => T | Promise<T>, options?: WaitForConditionOptions | undefined): Promise<T>;
|
|
/**
|
|
* Sometimes `Promise.delay` or `setTimeout` are inaccurate for large wait
|
|
* times. To safely wait for these long times (e.g. in the 5+ minute range), you
|
|
* can use `longSleep`.
|
|
*
|
|
* sYou can also pass a `progressCb` option which is a callback function that
|
|
* receives an object with the properties `elapsedMs`, `timeLeft`, and
|
|
* `progress`. This will be called on every wait interval so you can do your
|
|
* wait logging or whatever.
|
|
* @param {number} ms
|
|
* @param {LongSleepOptions} [opts]
|
|
* @returns {Promise<void>}
|
|
*/
|
|
export function longSleep(ms: number, { thresholdMs, intervalMs, progressCb, }?: LongSleepOptions | undefined): Promise<void>;
|
|
import B from "bluebird";
|
|
//# sourceMappingURL=asyncbox.d.ts.map
|