mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
104 lines
2.8 KiB
TypeScript
104 lines
2.8 KiB
TypeScript
// Type definitions for p-queue 2.3
|
|
// Project: https://github.com/sindresorhus/p-queue#readme
|
|
// Definitions by: BendingBender <https://github.com/BendingBender>
|
|
// Evan Shortiss <https://github.com/evanshortiss>
|
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
|
// TypeScript Version: 2.3
|
|
|
|
export = PQueue;
|
|
|
|
declare class PQueue<O extends PQueue.QueueAddOptions = PQueue.DefaultAddOptions> {
|
|
/**
|
|
* Size of the queue.
|
|
*/
|
|
size: number;
|
|
|
|
/**
|
|
* Number of pending promises.
|
|
*/
|
|
pending: number;
|
|
|
|
/**
|
|
* Whether the queue is currently paused.
|
|
*/
|
|
isPaused: boolean;
|
|
|
|
constructor(opts?: PQueue.Options<O>);
|
|
|
|
/**
|
|
* Returns the promise returned by calling fn.
|
|
* @param fn Promise-returning/async function.
|
|
*/
|
|
add<T>(fn: PQueue.Task<T>, opts?: O): Promise<T>;
|
|
|
|
/**
|
|
* Same as .add(), but accepts an array of async functions and
|
|
* returns a promise that resolves when all async functions are resolved.
|
|
* @param fn Array of Promise-returning/async functions.
|
|
*/
|
|
addAll<TAll>(fns: Array<PQueue.Task<TAll>>, opts?: O): Promise<TAll[]>;
|
|
|
|
/**
|
|
* Returns a promise that settles when the queue becomes empty.
|
|
* Can be called multiple times. Useful if you for example add
|
|
* additional items at a later time.
|
|
*/
|
|
onEmpty(): Promise<void>;
|
|
|
|
/**
|
|
* Returns a promise that settles when the queue becomes empty, and all
|
|
* promises have completed; queue.size === 0 && queue.pending === 0.
|
|
* The difference with .onEmpty is that .onIdle guarantees that all work
|
|
* from the queue has finished. .onEmpty merely signals that the queue is
|
|
* empty, but it could mean that some promises haven't completed yet.
|
|
*/
|
|
onIdle(): Promise<void>;
|
|
|
|
/**
|
|
* Start (or resume) executing enqueued tasks within concurrency limit.
|
|
* No need to call this if queue is not paused (via options.autoStart = false
|
|
* or by .pause() method.)
|
|
*/
|
|
start(): void;
|
|
|
|
/**
|
|
* Clear the queue.
|
|
*/
|
|
clear(): void;
|
|
|
|
/**
|
|
* Put queue execution on hold.
|
|
*/
|
|
pause(): void;
|
|
}
|
|
|
|
declare namespace PQueue {
|
|
interface QueueAddOptions {
|
|
[key: string]: any;
|
|
}
|
|
|
|
interface QueueClassConstructor<O extends QueueAddOptions> {
|
|
new(): QueueClass<O>;
|
|
}
|
|
|
|
interface QueueClass<O extends QueueAddOptions> {
|
|
size: number;
|
|
|
|
enqueue(run: () => void, options?: O): void;
|
|
|
|
dequeue(): (() => void) | undefined;
|
|
}
|
|
|
|
interface Options<O extends QueueAddOptions> {
|
|
concurrency?: number;
|
|
autoStart?: boolean;
|
|
queueClass?: QueueClassConstructor<O>;
|
|
}
|
|
|
|
interface DefaultAddOptions {
|
|
priority?: number;
|
|
}
|
|
|
|
type Task<T> = () => Promise<T>;
|
|
}
|