1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 | import type {EventEmitter} from 'events';
|
10 | import type {ForkOptions} from 'child_process';
|
11 | import type {ResourceLimits} from 'worker_threads';
|
12 |
|
13 | declare const CHILD_MESSAGE_CALL = 1;
|
14 |
|
15 | declare const CHILD_MESSAGE_END = 2;
|
16 |
|
17 | declare const CHILD_MESSAGE_INITIALIZE = 0;
|
18 |
|
19 | declare type ChildMessage =
|
20 | | ChildMessageInitialize
|
21 | | ChildMessageCall
|
22 | | ChildMessageEnd;
|
23 |
|
24 | declare type ChildMessageCall = [
|
25 | typeof CHILD_MESSAGE_CALL,
|
26 | boolean,
|
27 | string,
|
28 | Array<unknown>,
|
29 | ];
|
30 |
|
31 | declare type ChildMessageEnd = [typeof CHILD_MESSAGE_END, boolean];
|
32 |
|
33 | declare type ChildMessageInitialize = [
|
34 | typeof CHILD_MESSAGE_INITIALIZE,
|
35 | boolean,
|
36 | string,
|
37 |
|
38 | Array<unknown> | undefined,
|
39 |
|
40 | MessagePort_2 | undefined,
|
41 | ];
|
42 |
|
43 | declare type ComputeTaskPriorityCallback = (
|
44 | method: string,
|
45 | ...args: Array<unknown>
|
46 | ) => number;
|
47 |
|
48 | declare type ExcludeReservedKeys<K> = Exclude<K, ReservedKeys>;
|
49 |
|
50 |
|
51 |
|
52 |
|
53 |
|
54 |
|
55 | export declare class FifoQueue implements TaskQueue {
|
56 | private _workerQueues;
|
57 | private _sharedQueue;
|
58 | enqueue(task: QueueChildMessage, workerId?: number): void;
|
59 | dequeue(workerId: number): QueueChildMessage | null;
|
60 | }
|
61 |
|
62 | declare type FunctionLike = (...args: any) => unknown;
|
63 |
|
64 | declare type HeapItem = {
|
65 | priority: number;
|
66 | };
|
67 |
|
68 | export declare type JestWorkerFarm<T extends Record<string, unknown>> =
|
69 | Worker_2 & WorkerModule<T>;
|
70 |
|
71 | export declare function messageParent(
|
72 | message: unknown,
|
73 | parentProcess?: NodeJS.Process,
|
74 | ): void;
|
75 |
|
76 | declare type MessagePort_2 = typeof EventEmitter & {
|
77 | postMessage(message: unknown): void;
|
78 | };
|
79 |
|
80 | declare type MethodLikeKeys<T> = {
|
81 | [K in keyof T]: T[K] extends FunctionLike ? K : never;
|
82 | }[keyof T];
|
83 |
|
84 | declare class MinHeap<TItem extends HeapItem> {
|
85 | private _heap;
|
86 | peek(): TItem | null;
|
87 | add(item: TItem): void;
|
88 | poll(): TItem | null;
|
89 | }
|
90 |
|
91 | declare type OnCustomMessage = (message: Array<unknown> | unknown) => void;
|
92 |
|
93 | declare type OnEnd = (err: Error | null, result: unknown) => void;
|
94 |
|
95 | declare type OnStart = (worker: WorkerInterface) => void;
|
96 |
|
97 | declare type PoolExitResult = {
|
98 | forceExited: boolean;
|
99 | };
|
100 |
|
101 |
|
102 |
|
103 |
|
104 |
|
105 |
|
106 |
|
107 |
|
108 |
|
109 |
|
110 | export declare class PriorityQueue implements TaskQueue {
|
111 | private _computePriority;
|
112 | private _queue;
|
113 | private _sharedQueue;
|
114 | constructor(_computePriority: ComputeTaskPriorityCallback);
|
115 | enqueue(task: QueueChildMessage, workerId?: number): void;
|
116 | _enqueue(task: QueueChildMessage, queue: MinHeap<QueueItem>): void;
|
117 | dequeue(workerId: number): QueueChildMessage | null;
|
118 | _getWorkerQueue(workerId: number): MinHeap<QueueItem>;
|
119 | }
|
120 |
|
121 | export declare interface PromiseWithCustomMessage<T> extends Promise<T> {
|
122 | UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void;
|
123 | }
|
124 |
|
125 | declare type Promisify<T extends FunctionLike> = ReturnType<T> extends Promise<
|
126 | infer R
|
127 | >
|
128 | ? (...args: Parameters<T>) => Promise<R>
|
129 | : (...args: Parameters<T>) => Promise<ReturnType<T>>;
|
130 |
|
131 | declare type QueueChildMessage = {
|
132 | request: ChildMessageCall;
|
133 | onStart: OnStart;
|
134 | onEnd: OnEnd;
|
135 | onCustomMessage: OnCustomMessage;
|
136 | };
|
137 |
|
138 | declare type QueueItem = {
|
139 | task: QueueChildMessage;
|
140 | priority: number;
|
141 | };
|
142 |
|
143 | declare type ReservedKeys =
|
144 | | 'end'
|
145 | | 'getStderr'
|
146 | | 'getStdout'
|
147 | | 'setup'
|
148 | | 'teardown';
|
149 |
|
150 | export declare interface TaskQueue {
|
151 | |
152 |
|
153 |
|
154 |
|
155 |
|
156 |
|
157 |
|
158 | enqueue(task: QueueChildMessage, workerId?: number): void;
|
159 | |
160 |
|
161 |
|
162 |
|
163 | dequeue(workerId: number): QueueChildMessage | null;
|
164 | }
|
165 |
|
166 |
|
167 |
|
168 |
|
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 |
|
191 | declare class Worker_2 {
|
192 | private _ending;
|
193 | private _farm;
|
194 | private _options;
|
195 | private _workerPool;
|
196 | constructor(workerPath: string, options?: WorkerFarmOptions);
|
197 | private _bindExposedWorkerMethods;
|
198 | private _callFunctionWithArgs;
|
199 | getStderr(): NodeJS.ReadableStream;
|
200 | getStdout(): NodeJS.ReadableStream;
|
201 | end(): Promise<PoolExitResult>;
|
202 | }
|
203 | export {Worker_2 as Worker};
|
204 |
|
205 | declare type WorkerCallback = (
|
206 | workerId: number,
|
207 | request: ChildMessage,
|
208 | onStart: OnStart,
|
209 | onEnd: OnEnd,
|
210 | onCustomMessage: OnCustomMessage,
|
211 | ) => void;
|
212 |
|
213 | export declare type WorkerFarmOptions = {
|
214 | computeWorkerKey?: (method: string, ...args: Array<unknown>) => string | null;
|
215 | enableWorkerThreads?: boolean;
|
216 | exposedMethods?: ReadonlyArray<string>;
|
217 | forkOptions?: ForkOptions;
|
218 | maxRetries?: number;
|
219 | numWorkers?: number;
|
220 | resourceLimits?: ResourceLimits;
|
221 | setupArgs?: Array<unknown>;
|
222 | taskQueue?: TaskQueue;
|
223 | WorkerPool?: new (
|
224 | workerPath: string,
|
225 | options?: WorkerPoolOptions,
|
226 | ) => WorkerPoolInterface;
|
227 | workerSchedulingPolicy?: WorkerSchedulingPolicy;
|
228 | };
|
229 |
|
230 | declare interface WorkerInterface {
|
231 | send(
|
232 | request: ChildMessage,
|
233 | onProcessStart: OnStart,
|
234 | onProcessEnd: OnEnd,
|
235 | onCustomMessage: OnCustomMessage,
|
236 | ): void;
|
237 | waitForExit(): Promise<void>;
|
238 | forceExit(): void;
|
239 | getWorkerId(): number;
|
240 | getStderr(): NodeJS.ReadableStream | null;
|
241 | getStdout(): NodeJS.ReadableStream | null;
|
242 | }
|
243 |
|
244 | declare type WorkerModule<T> = {
|
245 | [K in keyof T as Extract<
|
246 | ExcludeReservedKeys<K>,
|
247 | MethodLikeKeys<T>
|
248 | >]: T[K] extends FunctionLike ? Promisify<T[K]> : never;
|
249 | };
|
250 |
|
251 | declare type WorkerOptions_2 = {
|
252 | forkOptions: ForkOptions;
|
253 | resourceLimits: ResourceLimits;
|
254 | setupArgs: Array<unknown>;
|
255 | maxRetries: number;
|
256 | workerId: number;
|
257 | workerData?: unknown;
|
258 | workerPath: string;
|
259 | };
|
260 |
|
261 | export declare interface WorkerPoolInterface {
|
262 | getStderr(): NodeJS.ReadableStream;
|
263 | getStdout(): NodeJS.ReadableStream;
|
264 | getWorkers(): Array<WorkerInterface>;
|
265 | createWorker(options: WorkerOptions_2): WorkerInterface;
|
266 | send: WorkerCallback;
|
267 | end(): Promise<PoolExitResult>;
|
268 | }
|
269 |
|
270 | export declare type WorkerPoolOptions = {
|
271 | setupArgs: Array<unknown>;
|
272 | forkOptions: ForkOptions;
|
273 | resourceLimits: ResourceLimits;
|
274 | maxRetries: number;
|
275 | numWorkers: number;
|
276 | enableWorkerThreads: boolean;
|
277 | };
|
278 |
|
279 | declare type WorkerSchedulingPolicy = 'round-robin' | 'in-order';
|
280 |
|
281 | export {};
|