@umijs/bundler-webpack 3.5.20 → 4.0.0-beta.4

package/compiled/terser-webpack-plugin/jest-worker/build/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { FarmOptions, PoolExitResult, PromiseWithCustomMessage, TaskQueue } from './types';
+export { default as PriorityQueue } from './PriorityQueue';
+export { default as FifoQueue } from './FifoQueue';
+export { default as messageParent } from './workers/messageParent';
+/**
+ * The Jest farm (publicly called "Worker") is a class that allows you to queue
+ * methods across multiple child processes, in order to parallelize work. This
+ * is done by providing an absolute path to a module that will be loaded on each
+ * of the child processes, and bridged to the main process.
+ *
+ * Bridged methods are specified by using the "exposedMethods" property of the
+ * "options" object. This is an array of strings, where each of them corresponds
+ * to the exported name in the loaded module.
+ *
+ * You can also control the amount of workers by using the "numWorkers" property
+ * of the "options" object, and the settings passed to fork the process through
+ * the "forkOptions" property. The amount of workers defaults to the amount of
+ * CPUS minus one.
+ *
+ * Queueing calls can be done in two ways:
+ *   - Standard method: calls will be redirected to the first available worker,
+ *     so they will get executed as soon as they can.
+ *
+ *   - Sticky method: if a "computeWorkerKey" method is provided within the
+ *     config, the resulting string of this method will be used as a key.
+ *     Every time this key is returned, it is guaranteed that your job will be
+ *     processed by the same worker. This is specially useful if your workers
+ *     are caching results.
+ */
+export declare class Worker {
+    private _ending;
+    private _farm;
+    private _options;
+    private _workerPool;
+    constructor(workerPath: string, options?: FarmOptions);
+    private _bindExposedWorkerMethods;
+    private _callFunctionWithArgs;
+    getStderr(): NodeJS.ReadableStream;
+    getStdout(): NodeJS.ReadableStream;
+    end(): Promise<PoolExitResult>;
+}
+export type { PromiseWithCustomMessage, TaskQueue };

package/compiled/terser-webpack-plugin/jest-worker/build/types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/// <reference types="node" />
+import type { ForkOptions } from 'child_process';
+import type { EventEmitter } from 'events';
+export interface ResourceLimits {
+    maxYoungGenerationSizeMb?: number;
+    maxOldGenerationSizeMb?: number;
+    codeRangeSizeMb?: number;
+    stackSizeMb?: number;
+}
+export declare const CHILD_MESSAGE_INITIALIZE: 0;
+export declare const CHILD_MESSAGE_CALL: 1;
+export declare const CHILD_MESSAGE_END: 2;
+export declare const PARENT_MESSAGE_OK: 0;
+export declare const PARENT_MESSAGE_CLIENT_ERROR: 1;
+export declare const PARENT_MESSAGE_SETUP_ERROR: 2;
+export declare const PARENT_MESSAGE_CUSTOM: 3;
+export declare type PARENT_MESSAGE_ERROR = typeof PARENT_MESSAGE_CLIENT_ERROR | typeof PARENT_MESSAGE_SETUP_ERROR;
+export interface WorkerPoolInterface {
+    getStderr(): NodeJS.ReadableStream;
+    getStdout(): NodeJS.ReadableStream;
+    getWorkers(): Array<WorkerInterface>;
+    createWorker(options: WorkerOptions): WorkerInterface;
+    send(workerId: number, request: ChildMessage, onStart: OnStart, onEnd: OnEnd, onCustomMessage: OnCustomMessage): void;
+    end(): Promise<PoolExitResult>;
+}
+export interface WorkerInterface {
+    send(request: ChildMessage, onProcessStart: OnStart, onProcessEnd: OnEnd, onCustomMessage: OnCustomMessage): void;
+    waitForExit(): Promise<void>;
+    forceExit(): void;
+    getWorkerId(): number;
+    getStderr(): NodeJS.ReadableStream | null;
+    getStdout(): NodeJS.ReadableStream | null;
+}
+export declare type PoolExitResult = {
+    forceExited: boolean;
+};
+export interface PromiseWithCustomMessage<T> extends Promise<T> {
+    UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void;
+}
+export type { ForkOptions };
+export interface TaskQueue {
+    /**
+     * Enqueues the task in the queue for the specified worker or adds it to the
+     * queue shared by all workers
+     * @param task the task to queue
+     * @param workerId the id of the worker that should process this task or undefined
+     * if there's no preference.
+     */
+    enqueue(task: QueueChildMessage, workerId?: number): void;
+    /**
+     * Dequeues the next item from the queue for the speified worker
+     * @param workerId the id of the worker for which the next task should be retrieved
+     */
+    dequeue(workerId: number): QueueChildMessage | null;
+}
+export declare type FarmOptions = {
+    computeWorkerKey?: (method: string, ...args: Array<unknown>) => string | null;
+    exposedMethods?: ReadonlyArray<string>;
+    forkOptions?: ForkOptions;
+    workerSchedulingPolicy?: 'round-robin' | 'in-order';
+    resourceLimits?: ResourceLimits;
+    setupArgs?: Array<unknown>;
+    maxRetries?: number;
+    numWorkers?: number;
+    taskQueue?: TaskQueue;
+    WorkerPool?: (workerPath: string, options?: WorkerPoolOptions) => WorkerPoolInterface;
+    enableWorkerThreads?: boolean;
+};
+export declare type WorkerPoolOptions = {
+    setupArgs: Array<unknown>;
+    forkOptions: ForkOptions;
+    resourceLimits: ResourceLimits;
+    maxRetries: number;
+    numWorkers: number;
+    enableWorkerThreads: boolean;
+};
+export declare type WorkerOptions = {
+    forkOptions: ForkOptions;
+    resourceLimits: ResourceLimits;
+    setupArgs: Array<unknown>;
+    maxRetries: number;
+    workerId: number;
+    workerPath: string;
+};
+export declare type MessagePort = typeof EventEmitter & {
+    postMessage(message: unknown): void;
+};
+export declare type MessageChannel = {
+    port1: MessagePort;
+    port2: MessagePort;
+};
+export declare type ChildMessageInitialize = [
+    typeof CHILD_MESSAGE_INITIALIZE,
+    boolean,
+    string,
+    // file
+    Array<unknown> | undefined,
+    // setupArgs
+    MessagePort | undefined
+];
+export declare type ChildMessageCall = [
+    typeof CHILD_MESSAGE_CALL,
+    boolean,
+    string,
+    Array<unknown>
+];
+export declare type ChildMessageEnd = [
+    typeof CHILD_MESSAGE_END,
+    boolean
+];
+export declare type ChildMessage = ChildMessageInitialize | ChildMessageCall | ChildMessageEnd;
+export declare type ParentMessageCustom = [
+    typeof PARENT_MESSAGE_CUSTOM,
+    unknown
+];
+export declare type ParentMessageOk = [
+    typeof PARENT_MESSAGE_OK,
+    unknown
+];
+export declare type ParentMessageError = [
+    PARENT_MESSAGE_ERROR,
+    string,
+    string,
+    string,
+    unknown
+];
+export declare type ParentMessage = ParentMessageOk | ParentMessageError | ParentMessageCustom;
+export declare type OnStart = (worker: WorkerInterface) => void;
+export declare type OnEnd = (err: Error | null, result: unknown) => void;
+export declare type OnCustomMessage = (message: Array<unknown> | unknown) => void;
+export declare type QueueChildMessage = {
+    request: ChildMessageCall;
+    onStart: OnStart;
+    onEnd: OnEnd;
+    onCustomMessage: OnCustomMessage;
+};