217 lines
7.3 KiB
Plaintext
217 lines
7.3 KiB
Plaintext
import { TransferListItem as TransferListItem$1, MessagePort } from 'worker_threads';
|
|
import { EventEmitter } from 'events';
|
|
import { AsyncResource } from 'async_hooks';
|
|
|
|
declare const kEventEmitter: unique symbol;
|
|
declare const kAsyncResource: unique symbol;
|
|
declare type EventEmitterOptions = typeof EventEmitter extends {
|
|
new (options?: infer T): EventEmitter;
|
|
} ? T : never;
|
|
declare type AsyncResourceOptions = typeof AsyncResource extends {
|
|
new (name: string, options?: infer T): AsyncResource;
|
|
} ? T : never;
|
|
declare type Options$1 = EventEmitterOptions & AsyncResourceOptions & {
|
|
name?: string;
|
|
};
|
|
declare class EventEmitterReferencingAsyncResource extends AsyncResource {
|
|
[kEventEmitter]: EventEmitter;
|
|
constructor(ee: EventEmitter, type: string, options?: AsyncResourceOptions);
|
|
get eventEmitter(): EventEmitter;
|
|
}
|
|
declare class EventEmitterAsyncResource extends EventEmitter {
|
|
[kAsyncResource]: EventEmitterReferencingAsyncResource;
|
|
constructor(options?: Options$1 | string);
|
|
emit(event: string | symbol, ...args: any[]): boolean;
|
|
emitDestroy(): void;
|
|
asyncId(): number;
|
|
triggerAsyncId(): number;
|
|
get asyncResource(): EventEmitterReferencingAsyncResource;
|
|
static get EventEmitterAsyncResource(): typeof EventEmitterAsyncResource;
|
|
}
|
|
|
|
/** Channel for communicating between main thread and workers */
|
|
interface TinypoolChannel {
|
|
/** Workers subscribing to messages */
|
|
onMessage(callback: (message: any) => void): void;
|
|
/** Called with worker's messages */
|
|
postMessage(message: any): void;
|
|
}
|
|
interface TinypoolWorker {
|
|
runtime: string;
|
|
initialize(options: {
|
|
env?: Record<string, string>;
|
|
argv?: string[];
|
|
execArgv?: string[];
|
|
resourceLimits?: any;
|
|
workerData: TinypoolData;
|
|
trackUnmanagedFds?: boolean;
|
|
}): void;
|
|
terminate(): Promise<any>;
|
|
postMessage(message: any, transferListItem?: TransferListItem$1[]): void;
|
|
setChannel?: (channel: TinypoolChannel) => void;
|
|
on(event: string, listener: (...args: any[]) => void): void;
|
|
once(event: string, listener: (...args: any[]) => void): void;
|
|
emit(event: string, ...data: any[]): void;
|
|
ref?: () => void;
|
|
unref?: () => void;
|
|
threadId: number;
|
|
}
|
|
/**
|
|
* Tinypool's internal messaging between main thread and workers.
|
|
* - Utilizers can use `__tinypool_worker_message__` property to identify
|
|
* these messages and ignore them.
|
|
*/
|
|
interface TinypoolWorkerMessage<T extends 'port' | 'pool' = 'port' | 'pool'> {
|
|
__tinypool_worker_message__: true;
|
|
source: T;
|
|
}
|
|
interface StartupMessage {
|
|
filename: string | null;
|
|
name: string;
|
|
port: MessagePort;
|
|
sharedBuffer: Int32Array;
|
|
useAtomics: boolean;
|
|
}
|
|
interface RequestMessage {
|
|
taskId: number;
|
|
task: any;
|
|
filename: string;
|
|
name: string;
|
|
}
|
|
interface ReadyMessage {
|
|
ready: true;
|
|
}
|
|
interface ResponseMessage {
|
|
taskId: number;
|
|
result: any;
|
|
error: unknown | null;
|
|
usedMemory: number;
|
|
}
|
|
interface TinypoolPrivateData {
|
|
workerId: number;
|
|
}
|
|
declare type TinypoolData = [TinypoolPrivateData, any];
|
|
declare const kTransferable: unique symbol;
|
|
declare const kValue: unique symbol;
|
|
declare const kQueueOptions: unique symbol;
|
|
declare function isTransferable(value: any): boolean;
|
|
declare function isMovable(value: any): boolean;
|
|
declare function markMovable(value: object): void;
|
|
interface Transferable {
|
|
readonly [kTransferable]: object;
|
|
readonly [kValue]: object;
|
|
}
|
|
interface Task {
|
|
readonly [kQueueOptions]: object | null;
|
|
cancel(): void;
|
|
}
|
|
interface TaskQueue {
|
|
readonly size: number;
|
|
shift(): Task | null;
|
|
remove(task: Task): void;
|
|
push(task: Task): void;
|
|
cancel(): void;
|
|
}
|
|
declare function isTaskQueue(value: any): boolean;
|
|
declare const kRequestCountField = 0;
|
|
declare const kResponseCountField = 1;
|
|
declare const kFieldCount = 2;
|
|
|
|
declare global {
|
|
namespace NodeJS {
|
|
interface Process {
|
|
__tinypool_state__: {
|
|
isTinypoolWorker: boolean;
|
|
isWorkerThread?: boolean;
|
|
isChildProcess?: boolean;
|
|
workerData: any;
|
|
workerId: number;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
interface AbortSignalEventTargetAddOptions {
|
|
once: boolean;
|
|
}
|
|
interface AbortSignalEventTarget {
|
|
addEventListener: (name: 'abort', listener: () => void, options?: AbortSignalEventTargetAddOptions) => void;
|
|
removeEventListener: (name: 'abort', listener: () => void) => void;
|
|
aborted?: boolean;
|
|
}
|
|
interface AbortSignalEventEmitter {
|
|
off: (name: 'abort', listener: () => void) => void;
|
|
once: (name: 'abort', listener: () => void) => void;
|
|
}
|
|
declare type AbortSignalAny = AbortSignalEventTarget | AbortSignalEventEmitter;
|
|
declare type ResourceLimits = Worker extends {
|
|
resourceLimits?: infer T;
|
|
} ? T : {};
|
|
interface Options {
|
|
filename?: string | null;
|
|
runtime?: 'worker_threads' | 'child_process';
|
|
name?: string;
|
|
minThreads?: number;
|
|
maxThreads?: number;
|
|
idleTimeout?: number;
|
|
terminateTimeout?: number;
|
|
maxQueue?: number | 'auto';
|
|
concurrentTasksPerWorker?: number;
|
|
useAtomics?: boolean;
|
|
resourceLimits?: ResourceLimits;
|
|
maxMemoryLimitBeforeRecycle?: number;
|
|
argv?: string[];
|
|
execArgv?: string[];
|
|
env?: Record<string, string>;
|
|
workerData?: any;
|
|
taskQueue?: TaskQueue;
|
|
trackUnmanagedFds?: boolean;
|
|
isolateWorkers?: boolean;
|
|
}
|
|
interface FilledOptions extends Options {
|
|
filename: string | null;
|
|
name: string;
|
|
runtime: NonNullable<Options['runtime']>;
|
|
minThreads: number;
|
|
maxThreads: number;
|
|
idleTimeout: number;
|
|
maxQueue: number;
|
|
concurrentTasksPerWorker: number;
|
|
useAtomics: boolean;
|
|
taskQueue: TaskQueue;
|
|
}
|
|
interface RunOptions {
|
|
transferList?: TransferList;
|
|
channel?: TinypoolChannel;
|
|
filename?: string | null;
|
|
signal?: AbortSignalAny | null;
|
|
name?: string | null;
|
|
runtime?: Options['runtime'];
|
|
}
|
|
declare type TransferList = MessagePort extends {
|
|
postMessage(value: any, transferList: infer T): any;
|
|
} ? T : never;
|
|
declare type TransferListItem = TransferList extends (infer T)[] ? T : never;
|
|
declare class Tinypool extends EventEmitterAsyncResource {
|
|
#private;
|
|
constructor(options?: Options);
|
|
run(task: any, options?: RunOptions): Promise<any>;
|
|
destroy(): Promise<void>;
|
|
get options(): FilledOptions;
|
|
get threads(): TinypoolWorker[];
|
|
get queueSize(): number;
|
|
cancelPendingTasks(): void;
|
|
recycleWorkers(options?: Pick<Options, 'runtime'>): Promise<void>;
|
|
get completed(): number;
|
|
get duration(): number;
|
|
static get isWorkerThread(): boolean;
|
|
static get workerData(): any;
|
|
static get version(): string;
|
|
static move(val: Transferable | TransferListItem | ArrayBufferView | ArrayBuffer | MessagePort): MessagePort | ArrayBuffer | Transferable | ArrayBufferView;
|
|
static get transferableSymbol(): symbol;
|
|
static get valueSymbol(): symbol;
|
|
static get queueOptionsSymbol(): symbol;
|
|
}
|
|
declare const _workerId: number;
|
|
|
|
export { Options, ReadyMessage, RequestMessage, ResponseMessage, StartupMessage, Task, TaskQueue, Tinypool, TinypoolChannel, TinypoolData, TinypoolPrivateData, TinypoolWorker, TinypoolWorkerMessage, Transferable, Tinypool as default, isMovable, isTaskQueue, isTransferable, kFieldCount, kQueueOptions, kRequestCountField, kResponseCountField, kTransferable, kValue, markMovable, _workerId as workerId };
|