concurrent-worker/dist/types.d.ts

Multithreading for javascript

export interface Input<T extends Array<unknown>> {
    data: [number, T];
}
export interface IResponse<R> {
    data: [number, ThenArg<R>, boolean];
}
export interface IWorkerContext {
    [key: string]: unknown;
}
export interface IWorkerConfig<T extends Array<unknown>, C extends IWorkerContext, R> {
    outTransferable?: (value: ThenArg<R>) => Transferable[];
    inTransferable?: (values: T) => Transferable[];
    context?: C;
    scripts?: string[];
    rootUrl?: string;
}
export interface IPoolConfig<T extends Array<unknown>, C extends IWorkerContext, R> extends IWorkerConfig<T, C, R> {
    workers?: number;
    timeout?: number;
}
export interface IWorker<T extends Array<unknown>, C, R> {
    clone: () => IWorker<T, C, R>;
    kill: () => void;
    run: RunFunc<T, R>;
}
export declare type WorkerThis<C extends IWorkerContext> = C & {
    rootUrl: string;
};
export declare type EmptyArray<T extends Array<unknown>> = T & {
    length: 0;
};
export declare type UnknownFunc<T extends Array<unknown>, R> = T extends EmptyArray<T> ? () => R : (args: T) => R;
export declare type RunFunc<T extends Array<unknown>, R> = UnknownFunc<T, ThenPromise<R>>;
export declare type Resolve<T> = (val: ThenArg<T> | PromiseLike<ThenArg<T>>) => void;
export declare type Reject = (error: any) => void;
export declare type ThenArg<T> = T extends Promise<infer U> ? ThenArg<U> : T;
export declare type ThenPromise<T> = Promise<ThenArg<T>>;