queue-tea/dist/index.d.ts

A simple, robust, persistable job & task queue written in typescript. Full type safety included.

import * as nanoevents from 'nanoevents';

interface Task<G, T extends keyof G = any> {
    id: string;
    name: T;
    options: any;
    retries: number;
    createdAt: number;
}
declare type QueueType<G> = Task<G, keyof G>[];
declare type Taskmap<I> = {
    [K in keyof I]: (options: I[K], info: {
        retries: number;
        createdAt: number;
    }) => Promise<void> | void;
};
declare type QueueEvents<G> = {
    success: (task: Task<G>) => void;
    fail: (task: Task<G>, error: any) => void;
    change: ({ tasks, remainingTasks, }: {
        tasks: Task<G>[];
        remainingTasks: number;
    }) => void;
};
declare type Primitives = string | number | boolean | null;
declare const TaskQueue: <G extends Record<string, O | undefined>, O extends Record<string, Primitives> = any>({ initialState, tasks, onChange, retryDelay, }: {
    initialState?: QueueType<G> | undefined;
    tasks: Taskmap<G>;
    onChange?: ((queue: QueueType<G>) => Promise<void>) | undefined;
    retryDelay?: ((retries: number) => number) | undefined;
}) => {
    run: () => Promise<void>;
    getState: () => "paused" | "running" | "idle";
    pause: () => void;
    getQueueItems: () => Task<G, keyof G>[];
    addEventListener: <E extends keyof QueueEvents<G>>(event: E, callback: QueueEvents<G>[E]) => nanoevents.Unsubscribe;
    queueTask: <K extends keyof G>(name: K, ...options: G[K] extends object ? [G[K]] : [undefined?]) => {
        id: string;
        task: Promise<void>;
    };
};

export default TaskQueue;