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 const CHILD_MESSAGE_MEM_USAGE = 3;
|
20 |
|
21 | declare type ChildMessage =
|
22 | | ChildMessageInitialize
|
23 | | ChildMessageCall
|
24 | | ChildMessageEnd
|
25 | | ChildMessageMemUsage;
|
26 |
|
27 | declare type ChildMessageCall = [
|
28 | typeof CHILD_MESSAGE_CALL,
|
29 | boolean,
|
30 | string,
|
31 | Array<unknown>,
|
32 | ];
|
33 |
|
34 | declare type ChildMessageEnd = [typeof CHILD_MESSAGE_END, boolean];
|
35 |
|
36 | declare type ChildMessageInitialize = [
|
37 | typeof CHILD_MESSAGE_INITIALIZE,
|
38 | boolean,
|
39 | string,
|
40 |
|
41 | Array<unknown> | undefined,
|
42 |
|
43 | MessagePort_2 | undefined,
|
44 | ];
|
45 |
|
46 | declare type ChildMessageMemUsage = [typeof CHILD_MESSAGE_MEM_USAGE];
|
47 |
|
48 | declare type ComputeTaskPriorityCallback = (
|
49 | method: string,
|
50 | ...args: Array<unknown>
|
51 | ) => number;
|
52 |
|
53 | declare type ExcludeReservedKeys<K> = Exclude<K, ReservedKeys>;
|
54 |
|
55 |
|
56 |
|
57 |
|
58 |
|
59 |
|
60 | export declare class FifoQueue implements TaskQueue {
|
61 | private _workerQueues;
|
62 | private _sharedQueue;
|
63 | enqueue(task: QueueChildMessage, workerId?: number): void;
|
64 | dequeue(workerId: number): QueueChildMessage | null;
|
65 | }
|
66 |
|
67 | declare type FunctionLike = (...args: any) => unknown;
|
68 |
|
69 | declare type HeapItem = {
|
70 | priority: number;
|
71 | };
|
72 |
|
73 | export declare type JestWorkerFarm<T extends Record<string, unknown>> =
|
74 | Worker_2 & WorkerModule<T>;
|
75 |
|
76 | export declare function messageParent(
|
77 | message: unknown,
|
78 | parentProcess?: NodeJS.Process,
|
79 | ): void;
|
80 |
|
81 | declare type MessagePort_2 = typeof EventEmitter & {
|
82 | postMessage(message: unknown): void;
|
83 | };
|
84 |
|
85 | declare type MethodLikeKeys<T> = {
|
86 | [K in keyof T]: T[K] extends FunctionLike ? K : never;
|
87 | }[keyof T];
|
88 |
|
89 | declare class MinHeap<TItem extends HeapItem> {
|
90 | private _heap;
|
91 | peek(): TItem | null;
|
92 | add(item: TItem): void;
|
93 | poll(): TItem | null;
|
94 | }
|
95 |
|
96 | declare type OnCustomMessage = (message: Array<unknown> | unknown) => void;
|
97 |
|
98 | declare type OnEnd = (err: Error | null, result: unknown) => void;
|
99 |
|
100 | declare type OnStart = (worker: WorkerInterface) => void;
|
101 |
|
102 | declare type OnStateChangeHandler = (
|
103 | state: WorkerStates,
|
104 | oldState: WorkerStates,
|
105 | ) => void;
|
106 |
|
107 | declare type PoolExitResult = {
|
108 | forceExited: boolean;
|
109 | };
|
110 |
|
111 |
|
112 |
|
113 |
|
114 |
|
115 |
|
116 |
|
117 |
|
118 |
|
119 |
|
120 | export declare class PriorityQueue implements TaskQueue {
|
121 | private _computePriority;
|
122 | private _queue;
|
123 | private _sharedQueue;
|
124 | constructor(_computePriority: ComputeTaskPriorityCallback);
|
125 | enqueue(task: QueueChildMessage, workerId?: number): void;
|
126 | _enqueue(task: QueueChildMessage, queue: MinHeap<QueueItem>): void;
|
127 | dequeue(workerId: number): QueueChildMessage | null;
|
128 | _getWorkerQueue(workerId: number): MinHeap<QueueItem>;
|
129 | }
|
130 |
|
131 | export declare interface PromiseWithCustomMessage<T> extends Promise<T> {
|
132 | UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void;
|
133 | }
|
134 |
|
135 | declare type Promisify<T extends FunctionLike> = ReturnType<T> extends Promise<
|
136 | infer R
|
137 | >
|
138 | ? (...args: Parameters<T>) => Promise<R>
|
139 | : (...args: Parameters<T>) => Promise<ReturnType<T>>;
|
140 |
|
141 | declare type QueueChildMessage = {
|
142 | request: ChildMessageCall;
|
143 | onStart: OnStart;
|
144 | onEnd: OnEnd;
|
145 | onCustomMessage: OnCustomMessage;
|
146 | };
|
147 |
|
148 | declare type QueueItem = {
|
149 | task: QueueChildMessage;
|
150 | priority: number;
|
151 | };
|
152 |
|
153 | declare type ReservedKeys =
|
154 | | 'end'
|
155 | | 'getStderr'
|
156 | | 'getStdout'
|
157 | | 'setup'
|
158 | | 'teardown';
|
159 |
|
160 | export declare interface TaskQueue {
|
161 | |
162 |
|
163 |
|
164 |
|
165 |
|
166 |
|
167 |
|
168 | enqueue(task: QueueChildMessage, workerId?: number): void;
|
169 | |
170 |
|
171 |
|
172 |
|
173 | dequeue(workerId: number): QueueChildMessage | null;
|
174 | }
|
175 |
|
176 |
|
177 |
|
178 |
|
179 |
|
180 |
|
181 |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 |
|
191 |
|
192 |
|
193 |
|
194 |
|
195 |
|
196 |
|
197 |
|
198 |
|
199 |
|
200 |
|
201 | declare class Worker_2 {
|
202 | private _ending;
|
203 | private _farm;
|
204 | private _options;
|
205 | private _workerPool;
|
206 | constructor(workerPath: string, options?: WorkerFarmOptions);
|
207 | private _bindExposedWorkerMethods;
|
208 | private _callFunctionWithArgs;
|
209 | getStderr(): NodeJS.ReadableStream;
|
210 | getStdout(): NodeJS.ReadableStream;
|
211 | end(): Promise<PoolExitResult>;
|
212 | }
|
213 | export {Worker_2 as Worker};
|
214 |
|
215 | declare type WorkerCallback = (
|
216 | workerId: number,
|
217 | request: ChildMessage,
|
218 | onStart: OnStart,
|
219 | onEnd: OnEnd,
|
220 | onCustomMessage: OnCustomMessage,
|
221 | ) => void;
|
222 |
|
223 | declare enum WorkerEvents {
|
224 | STATE_CHANGE = 'state-change',
|
225 | }
|
226 |
|
227 | export declare type WorkerFarmOptions = {
|
228 | computeWorkerKey?: (method: string, ...args: Array<unknown>) => string | null;
|
229 | enableWorkerThreads?: boolean;
|
230 | exposedMethods?: ReadonlyArray<string>;
|
231 | forkOptions?: ForkOptions;
|
232 | maxRetries?: number;
|
233 | numWorkers?: number;
|
234 | resourceLimits?: ResourceLimits;
|
235 | setupArgs?: Array<unknown>;
|
236 | taskQueue?: TaskQueue;
|
237 | WorkerPool?: new (
|
238 | workerPath: string,
|
239 | options?: WorkerPoolOptions,
|
240 | ) => WorkerPoolInterface;
|
241 | workerSchedulingPolicy?: WorkerSchedulingPolicy;
|
242 | idleMemoryLimit?: number;
|
243 | };
|
244 |
|
245 | declare interface WorkerInterface {
|
246 | get state(): WorkerStates;
|
247 | send(
|
248 | request: ChildMessage,
|
249 | onProcessStart: OnStart,
|
250 | onProcessEnd: OnEnd,
|
251 | onCustomMessage: OnCustomMessage,
|
252 | ): void;
|
253 | waitForExit(): Promise<void>;
|
254 | forceExit(): void;
|
255 | getWorkerId(): number;
|
256 | getStderr(): NodeJS.ReadableStream | null;
|
257 | getStdout(): NodeJS.ReadableStream | null;
|
258 | |
259 |
|
260 |
|
261 | getWorkerSystemId(): number;
|
262 | getMemoryUsage(): Promise<number | null>;
|
263 | |
264 |
|
265 |
|
266 | isWorkerRunning(): boolean;
|
267 | |
268 |
|
269 |
|
270 |
|
271 |
|
272 |
|
273 |
|
274 | waitForWorkerReady(): Promise<void>;
|
275 | }
|
276 |
|
277 | declare type WorkerModule<T> = {
|
278 | [K in keyof T as Extract<
|
279 | ExcludeReservedKeys<K>,
|
280 | MethodLikeKeys<T>
|
281 | >]: T[K] extends FunctionLike ? Promisify<T[K]> : never;
|
282 | };
|
283 |
|
284 | declare type WorkerOptions_2 = {
|
285 | forkOptions: ForkOptions;
|
286 | resourceLimits: ResourceLimits;
|
287 | setupArgs: Array<unknown>;
|
288 | maxRetries: number;
|
289 | workerId: number;
|
290 | workerData?: unknown;
|
291 | workerPath: string;
|
292 | |
293 |
|
294 |
|
295 |
|
296 |
|
297 |
|
298 |
|
299 |
|
300 |
|
301 | idleMemoryLimit?: number;
|
302 | |
303 |
|
304 |
|
305 |
|
306 | childWorkerPath?: string;
|
307 | |
308 |
|
309 |
|
310 |
|
311 | silent?: boolean;
|
312 | |
313 |
|
314 |
|
315 | on?: {
|
316 | [WorkerEvents.STATE_CHANGE]:
|
317 | | OnStateChangeHandler
|
318 | | ReadonlyArray<OnStateChangeHandler>;
|
319 | };
|
320 | };
|
321 |
|
322 | export declare interface WorkerPoolInterface {
|
323 | getStderr(): NodeJS.ReadableStream;
|
324 | getStdout(): NodeJS.ReadableStream;
|
325 | getWorkers(): Array<WorkerInterface>;
|
326 | createWorker(options: WorkerOptions_2): WorkerInterface;
|
327 | send: WorkerCallback;
|
328 | end(): Promise<PoolExitResult>;
|
329 | }
|
330 |
|
331 | export declare type WorkerPoolOptions = {
|
332 | setupArgs: Array<unknown>;
|
333 | forkOptions: ForkOptions;
|
334 | resourceLimits: ResourceLimits;
|
335 | maxRetries: number;
|
336 | numWorkers: number;
|
337 | enableWorkerThreads: boolean;
|
338 | idleMemoryLimit?: number;
|
339 | };
|
340 |
|
341 | declare type WorkerSchedulingPolicy = 'round-robin' | 'in-order';
|
342 |
|
343 | declare enum WorkerStates {
|
344 | STARTING = 'starting',
|
345 | OK = 'ok',
|
346 | OUT_OF_MEMORY = 'oom',
|
347 | RESTARTING = 'restarting',
|
348 | SHUTTING_DOWN = 'shutting-down',
|
349 | SHUT_DOWN = 'shut-down',
|
350 | }
|
351 |
|
352 | export {};
|