qyu/dist/cjs/QyuBase.d.ts

A general-purpose asynchronous job queue for Node.js

import { MaybePromise } from './utils/MaybePromise.js';
export { QyuBase, type QyuInputOptions, type JobAddInput, type JobFunction };
declare class QyuBase {
    isAtMaxConcurrency: boolean;
    isRunningJobChannels: boolean;
    isPaused: boolean;
    opts: NormalizedQyuOptions;
    private whenEmptyDeferred;
    private whenFreeDeferred;
    private jobChannels;
    private jobQueue;
    constructor(opts?: QyuInputOptions);
    set(newOpts: QyuInputOptions): void;
    add<T>(input: JobAddInput<T>): Promise<T>;
    add<T extends readonly JobAddInput<unknown>[] | readonly []>(input: T): Promise<{
        [K in keyof T]: T[K] extends JobAddInput<infer RetVal> ? RetVal : never;
    }>;
    pause(): Promise<undefined | void>;
    resume(): undefined | void;
    empty(): Promise<void[]>;
    whenEmpty(): Promise<undefined | void>;
    whenFree(): Promise<undefined | void>;
    private enqueue;
    private dequeue;
    private runJobChannel;
    private runJobChannels;
}
type JobFunction<TRes> = () => MaybePromise<TRes>;
type NormalizedQyuOptions = Required<{
    [K in keyof QyuInputOptions]: NonNullable<QyuInputOptions[K]>;
}>;
interface QyuInputOptions {
    concurrency?: number | undefined | null;
    capacity?: number | undefined | null;
    rampUpTime?: number | undefined | null;
}
type JobAddInput<JobResultVal> = JobFunction<JobResultVal> | {
    fn: JobFunction<JobResultVal>;
    signal?: AbortSignal;
    timeout?: number | undefined;
    priority?: number | undefined;
};