@atlaspack/workers 2.14.21-typescript-e99c742e9.0 → 2.14.21-typescript-bc4459c37.0

package/lib/Handle.d.ts

@@ -0,0 +1,19 @@
+export type HandleFunction = (...args: Array<any>) => any;
+type HandleOpts = {
+    fn?: HandleFunction;
+    childId?: number | null | undefined;
+    id?: number;
+};
+export default class Handle {
+    id: number;
+    childId: number | null | undefined;
+    fn: HandleFunction | null | undefined;
+    constructor(opts: HandleOpts);
+    dispose(): void;
+    serialize(): {
+        childId: number | null | undefined;
+        id: number;
+    };
+    static deserialize(opts: HandleOpts): Handle;
+}
+export {};

package/lib/Handle.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+var _package = _interopRequireDefault(require("../package.json"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let HANDLE_ID = 0;
+const handleById = new Map();
+class Handle {
+  constructor(opts) {
+    this.id = opts.id ?? ++HANDLE_ID;
+    this.fn = opts.fn;
+    this.childId = opts.childId;
+    handleById.set(this.id, this);
+  }
+  dispose() {
+    handleById.delete(this.id);
+  }
+  serialize() {
+    return {
+      id: this.id,
+      childId: this.childId
+    };
+  }
+  static deserialize(opts) {
+    return new Handle(opts);
+  }
+}
+
+// Register the Handle as a serializable class so that it will properly be deserialized
+// by anything that uses WorkerFarm.
+exports.default = Handle;
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:Handle`, Handle);

package/lib/Worker.d.ts

@@ -0,0 +1,40 @@
+import type { FilePath } from '@atlaspack/types-internal';
+import type { BackendType, WorkerImpl, WorkerMessage } from './types';
+import type { SharedReference } from './WorkerFarm';
+import EventEmitter from 'events';
+export type WorkerCall = {
+    method?: string;
+    handle?: number;
+    args: ReadonlyArray<any>;
+    retries: number;
+    skipReadyCheck?: boolean;
+    resolve: (result: Promise<any> | any) => void;
+    reject: (error?: any) => void;
+};
+type WorkerOpts = {
+    forcedKillTime: number;
+    backend: BackendType;
+    shouldPatchConsole?: boolean;
+    shouldTrace?: boolean;
+    sharedReferences: ReadonlyMap<SharedReference, unknown>;
+};
+export default class Worker extends EventEmitter {
+    readonly options: WorkerOpts;
+    worker: WorkerImpl;
+    id: number;
+    sentSharedReferences: Set<SharedReference>;
+    calls: Map<number, WorkerCall>;
+    exitCode: number | null | undefined;
+    callId: number;
+    ready: boolean;
+    stopped: boolean;
+    isStopping: boolean;
+    constructor(options: WorkerOpts);
+    fork(forkModule: FilePath): Promise<void>;
+    sendSharedReference(ref: SharedReference, value: unknown): Promise<any>;
+    send(data: WorkerMessage): void;
+    call(call: WorkerCall): void;
+    receive(message: WorkerMessage): void;
+    stop(): Promise<void>;
+}
+export {};

package/lib/Worker.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _events() {
+  const data = _interopRequireDefault(require("events"));
+  _events = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+var _backend = require("./backend");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let WORKER_ID = 0;
+class Worker extends _events().default {
+  // @ts-expect-error TS2564
+
+  id = WORKER_ID++;
+  sentSharedReferences = new Set();
+  calls = new Map();
+  exitCode = null;
+  callId = 0;
+  ready = false;
+  stopped = false;
+  isStopping = false;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  async fork(forkModule) {
+    let filteredArgs = [];
+    if (process.execArgv) {
+      filteredArgs = process.execArgv.filter(v => !/^--(debug|inspect|no-opt|max-old-space-size=|max-semi-space-size=|expose-gc)/.test(v));
+      for (let i = 0; i < filteredArgs.length; i++) {
+        let arg = filteredArgs[i];
+        let isArgWithParam = (arg === '-r' || arg === '--require') && filteredArgs[i + 1] === '@atlaspack/register' || arg === '--title';
+        if (isArgWithParam) {
+          filteredArgs.splice(i, 2);
+          i--;
+        }
+      }
+    }
+
+    // Workaround for https://github.com/nodejs/node/issues/29117
+    if (process.env.NODE_OPTIONS) {
+      // arg parsing logic adapted from https://stackoverflow.com/a/46946420/2352201
+      let opts = [''];
+      let quote = false;
+      for (let c of (0, _nullthrows().default)(process.env.NODE_OPTIONS.match(/.|^$/g))) {
+        if (c === '"') {
+          quote = !quote;
+        } else if (!quote && c === ' ') {
+          opts.push('');
+        } else {
+          opts[opts.length - 1] += c.replace(/\\(.)/, '$1');
+        }
+      }
+      for (let i = 0; i < opts.length; i++) {
+        let opt = opts[i];
+        if (opt === '-r' || opt === '--require') {
+          filteredArgs.push(opt, opts[i + 1]);
+          i++;
+        }
+      }
+    }
+    let onMessage = data => this.receive(data);
+    let onExit = code => {
+      this.exitCode = code;
+      this.emit('exit', code);
+    };
+    let onError = err => {
+      this.emit('error', err);
+    };
+    let WorkerBackend = (0, _backend.getWorkerBackend)(this.options.backend);
+    this.worker = new WorkerBackend(filteredArgs, onMessage, onError, onExit);
+    await this.worker.start();
+    await new Promise((resolve, reject) => {
+      this.call({
+        method: 'childInit',
+        args: [forkModule, {
+          shouldPatchConsole: !!this.options.shouldPatchConsole,
+          shouldTrace: !!this.options.shouldTrace
+        }],
+        retries: 0,
+        skipReadyCheck: true,
+        resolve,
+        reject
+      });
+    });
+    let sharedRefs = this.options.sharedReferences;
+    let refsShared = new Set();
+    // in case more refs are created while initial refs are sending
+    while (refsShared.size < sharedRefs.size) {
+      await Promise.all([...sharedRefs]
+      // @ts-expect-error TS2769
+      .filter(([ref]) => !refsShared.has(ref)).map(async ([ref, value]) => {
+        await this.sendSharedReference(ref, value);
+        refsShared.add(ref);
+      }));
+    }
+    this.ready = true;
+    this.emit('ready');
+  }
+  sendSharedReference(ref, value) {
+    this.sentSharedReferences.add(ref);
+    return new Promise((resolve, reject) => {
+      this.call({
+        method: 'createSharedReference',
+        args: [ref, value],
+        resolve,
+        reject,
+        retries: 0,
+        skipReadyCheck: true
+      });
+    });
+  }
+  send(data) {
+    this.worker.send(data);
+  }
+  call(call) {
+    if (this.stopped || this.isStopping) {
+      return;
+    }
+    let idx = this.callId++;
+    this.calls.set(idx, call);
+    let msg = {
+      type: 'request',
+      idx: idx,
+      child: this.id,
+      handle: call.handle,
+      method: call.method,
+      args: call.args
+    };
+    if (this.ready || call.skipReadyCheck === true) {
+      // @ts-expect-error TS2345
+      this.send(msg);
+    } else {
+      // @ts-expect-error TS2345
+      this.once('ready', () => this.send(msg));
+    }
+  }
+  receive(message) {
+    if (this.stopped || this.isStopping) {
+      return;
+    }
+    if (message.type === 'request') {
+      this.emit('request', message);
+    } else if (message.type === 'response') {
+      let idx = message.idx;
+      if (idx == null) {
+        return;
+      }
+      let call = this.calls.get(idx);
+      if (!call) {
+        // Return for unknown calls, these might accur if a third party process uses workers
+        return;
+      }
+      if (message.contentType === 'error') {
+        call.reject(new (_diagnostic().default)({
+          diagnostic: message.content
+        }));
+      } else {
+        call.resolve(message.content);
+      }
+      this.calls.delete(idx);
+      this.emit('response', message);
+    }
+  }
+  async stop() {
+    if (!this.stopped) {
+      this.stopped = true;
+      if (this.worker) {
+        await this.worker.stop();
+      }
+    }
+  }
+}
+exports.default = Worker;

package/lib/WorkerFarm.d.ts

@@ -0,0 +1,93 @@
+import type { ErrorWithCode, FilePath } from '@atlaspack/types-internal';
+import type { CallRequest, HandleCallRequest, WorkerRequest, BackendType } from './types';
+import type { HandleFunction } from './Handle';
+import EventEmitter from 'events';
+import Worker, { WorkerCall } from './Worker';
+import Handle from './Handle';
+import { SamplingProfiler } from '@atlaspack/profiler';
+export type SharedReference = number;
+export type FarmOptions = {
+    maxConcurrentWorkers: number;
+    maxConcurrentCallsPerWorker: number;
+    forcedKillTime: number;
+    useLocalWorker: boolean;
+    warmWorkers: boolean;
+    workerPath?: FilePath;
+    backend: BackendType;
+    shouldPatchConsole?: boolean;
+    shouldTrace?: boolean;
+};
+type WorkerModule = {
+    readonly [key: string]: (...args: Array<unknown>) => Promise<unknown>;
+};
+export type WorkerApi = {
+    callMaster(arg1: CallRequest, arg2?: boolean | null | undefined): Promise<unknown>;
+    createReverseHandle(fn: HandleFunction): Handle;
+    getSharedReference(ref: SharedReference): unknown;
+    resolveSharedReference(value: unknown): SharedReference | null | undefined;
+    callChild?: (childId: number, request: HandleCallRequest) => Promise<unknown>;
+};
+export { Handle };
+/**
+ * workerPath should always be defined inside farmOptions
+ */
+export default class WorkerFarm extends EventEmitter {
+    callQueue: Array<WorkerCall>;
+    ending: boolean;
+    localWorker: WorkerModule;
+    localWorkerInit: Promise<undefined> | null | undefined;
+    options: FarmOptions;
+    run: HandleFunction;
+    warmWorkers: number;
+    readyWorkers: number;
+    workers: Map<number, Worker>;
+    handles: Map<number, Handle>;
+    sharedReferences: Map<SharedReference, unknown>;
+    sharedReferencesByValue: Map<unknown, SharedReference>;
+    serializedSharedReferences: Map<SharedReference, ArrayBuffer | null | undefined>;
+    profiler: SamplingProfiler | null | undefined;
+    constructor(farmOptions?: Partial<FarmOptions>);
+    workerApi: {
+        callChild: (childId: number, request: HandleCallRequest) => Promise<unknown>;
+        callMaster: (request: CallRequest, awaitResponse?: boolean | null | undefined) => Promise<unknown>;
+        createReverseHandle: (fn: HandleFunction) => Handle;
+        getSharedReference: (ref: SharedReference) => unknown;
+        resolveSharedReference: (value: unknown) => undefined | SharedReference;
+        runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
+    };
+    warmupWorker(method: string, args: Array<any>): void;
+    shouldStartRemoteWorkers(): boolean;
+    createHandle(method: string, useMainThread?: boolean): HandleFunction;
+    onError(error: ErrorWithCode, worker: Worker): undefined | Promise<undefined>;
+    startChild(): void;
+    stopWorker(worker: Worker): Promise<void>;
+    processQueue(): void;
+    callWorker(worker: Worker, call: WorkerCall): Promise<void>;
+    processRequest(data: {
+        location: FilePath;
+    } & Partial<WorkerRequest>, worker?: Worker): Promise<string | null | undefined>;
+    addCall(method: string, args: Array<any>): Promise<any>;
+    end(): Promise<void>;
+    startMaxWorkers(): void;
+    shouldUseRemoteWorkers(): boolean;
+    createReverseHandle(fn: HandleFunction): Handle;
+    createSharedReference(value: unknown, isCacheable?: boolean): {
+        ref: SharedReference;
+        dispose(): Promise<unknown>;
+    };
+    getSerializedSharedReference(ref: SharedReference): ArrayBuffer;
+    startProfile(): Promise<void>;
+    endProfile(): Promise<void>;
+    callAllWorkers(method: string, args: Array<any>): Promise<void>;
+    takeHeapSnapshot(): Promise<void>;
+    static getNumWorkers(): number;
+    static isWorker(): boolean;
+    static getWorkerApi(): {
+        callMaster: (request: CallRequest, awaitResponse?: boolean | null | undefined) => Promise<unknown>;
+        createReverseHandle: (fn: (...args: Array<any>) => unknown) => Handle;
+        getSharedReference: (ref: SharedReference) => unknown;
+        resolveSharedReference: (value: unknown) => undefined | SharedReference;
+        runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
+    };
+    static getConcurrentCallsPerWorker(defaultValue?: number): number;
+}