@atlaspack/workers 2.14.5-canary.24 → 2.14.5-canary.241

package/dist/web/WebWorker.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKER_PATH = void 0;
+const build_cache_1 = require("@atlaspack/build-cache");
+const utils_1 = require("@atlaspack/utils");
+let id = 0;
+// @ts-expect-error This is actually a module
+exports.WORKER_PATH = new URL('./WebChild.js', import.meta.url);
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+    // @ts-expect-error This is actually a module
+    exports.WORKER_PATH = new URL('./WebChild.ts', import.meta.url);
+}
+// @ts-expect-error TS2420
+class WebWorker {
+    constructor(execArgv, onMessage, onError, onExit) {
+        this.execArgv = execArgv;
+        this.onMessage = onMessage;
+        this.onError = onError;
+        this.onExit = onExit;
+    }
+    start() {
+        // @ts-expect-error TS1470
+        this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
+            name: `Parcel Worker ${id++}`,
+            type: 'module',
+        });
+        let { deferred, promise } = (0, utils_1.makeDeferredWithPromise)();
+        this.worker.onmessage = ({ data }) => {
+            if (data === 'online') {
+                // @ts-expect-error TS2554
+                deferred.resolve();
+                return;
+            }
+            this.handleMessage(data);
+        };
+        // @ts-expect-error TS2322
+        this.worker.onerror = this.onError;
+        // Web workers can't crash or intentionally stop on their own, apart from stop() below
+        // this.worker.on('exit', this.onExit);
+        // @ts-expect-error TS2322
+        return promise;
+    }
+    stop() {
+        if (!this.stopping) {
+            // @ts-expect-error TS2322
+            this.stopping = (async () => {
+                this.worker.postMessage('stop');
+                let { deferred, promise } = (0, utils_1.makeDeferredWithPromise)();
+                this.worker.addEventListener('message', ({ data }) => {
+                    if (data === 'stopped') {
+                        // @ts-expect-error TS2554
+                        deferred.resolve();
+                    }
+                });
+                await promise;
+                this.worker.terminate();
+                this.onExit(0);
+            })();
+        }
+        // @ts-expect-error TS2322
+        return this.stopping;
+    }
+    handleMessage(data) {
+        this.onMessage((0, build_cache_1.restoreDeserializedObject)(data));
+    }
+    send(data) {
+        this.worker.postMessage((0, build_cache_1.prepareForSerialization)(data));
+    }
+}
+exports.default = WebWorker;

package/index.d.ts

@@ -1,4 +1,6 @@
-import {FilePath} from '@atlaspack/types';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type {FilePath} from '@atlaspack/types';
+import type EventEmitter from 'events';
 
 type BackendType = 'process' | 'threads';
 
@@ -14,10 +16,101 @@ export type FarmOptions = {
   shouldTrace?: boolean;
 };
 
-declare class WorkerFarm {
-  constructor(options: FarmOptions);
+export class Bus extends EventEmitter {
+  emit(event: string, ...args: Array<any>): boolean;
+}
+
+export const bus: Bus;
 
+export declare class WorkerFarm {
+  ending: boolean;
+  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>;
+  };
+  constructor(options: Partial<FarmOptions>);
+  createSharedReference(
+    value: unknown,
+    isCacheable?: boolean,
+  ): {
+    ref: SharedReference;
+    dispose(): Promise<unknown>;
+  };
+  startProfile(): Promise<void>;
+  endProfile(): Promise<void>;
+  takeHeapSnapshot(): Promise<void>;
+  createHandle(method: string, useMainThread?: boolean): HandleFunction;
+  createReverseHandle(fn: HandleFunction): Handle;
+  callAllWorkers(method: string, args: Array<any>): Promise<void>;
+  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>;
+  };
   end(): Promise<void>;
+  static isWorker(): boolean;
 }
 
 export default WorkerFarm;
+
+export type SharedReference = number;
+
+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 type HandleFunction = (...args: Array<any>) => any;
+
+export type LocationCallRequest = {
+  args: ReadonlyArray<unknown>;
+  location: string;
+  method?: string;
+};
+
+export type HandleCallRequest = {
+  args: ReadonlyArray<unknown>;
+  handle: number;
+};
+
+export type CallRequest = LocationCallRequest | HandleCallRequest;
+
+type HandleOpts = {
+  fn?: HandleFunction;
+  childId?: number | null | undefined;
+  id?: number;
+};
+
+export declare 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;
+}

package/lib/Handle.js

@@ -13,10 +13,7 @@ function _buildCache() {
 }
 var _package = _interopRequireDefault(require("../package.json"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// $FlowFixMe
 let HANDLE_ID = 0;
-// $FlowFixMe
-
 const handleById = new Map();
 class Handle {
   constructor(opts) {

package/lib/Worker.js

@@ -29,6 +29,8 @@ 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();
@@ -105,7 +107,9 @@ class Worker extends _events().default {
     let refsShared = new Set();
     // in case more refs are created while initial refs are sending
     while (refsShared.size < sharedRefs.size) {
-      await Promise.all([...sharedRefs].filter(([ref]) => !refsShared.has(ref)).map(async ([ref, value]) => {
+      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);
       }));
@@ -144,8 +148,10 @@ class Worker extends _events().default {
       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));
     }
   }

package/lib/WorkerFarm.js

@@ -108,9 +108,9 @@ class WorkerFarm extends _events().default {
     if (!this.options.workerPath) {
       throw new Error('Please provide a worker path!');
     }
-
-    // $FlowFixMe
     this.localWorker = require(this.options.workerPath);
+
+    // @ts-expect-error TS2322
     this.localWorkerInit = this.localWorker.childInit != null ? this.localWorker.childInit() : null;
     this.run = this.createHandle('run');
 
@@ -127,9 +127,9 @@ class WorkerFarm extends _events().default {
   }
   workerApi = {
     callMaster: async (request, awaitResponse = true) => {
-      // $FlowFixMe
       let result = await this.processRequest({
         ...request,
+        // @ts-expect-error TS2322
         awaitResponse
       });
       return (0, _buildCache().deserialize)((0, _buildCache().serialize)(result));
@@ -203,6 +203,7 @@ class WorkerFarm extends _events().default {
   onError(error, worker) {
     // Handle ipc errors
     if (error.code === 'ERR_IPC_CHANNEL_CLOSED') {
+      // @ts-expect-error TS2322
       return this.stopWorker(worker);
     } else {
       _logger().default.error(error, '@atlaspack/workers');
@@ -261,6 +262,7 @@ class WorkerFarm extends _events().default {
         continue;
       }
       if (worker.calls.size < this.options.maxConcurrentCallsPerWorker) {
+        // @ts-expect-error TS2345
         this.callWorker(worker, this.callQueue.shift());
       }
     }
@@ -287,7 +289,7 @@ class WorkerFarm extends _events().default {
       var _this$handles$get;
       mod = (0, _nullthrows().default)((_this$handles$get = this.handles.get(handleId)) === null || _this$handles$get === void 0 ? void 0 : _this$handles$get.fn);
     } else if (location) {
-      // $FlowFixMe
+      // @ts-expect-error TS2339
       if (process.browser) {
         if (location === '@atlaspack/workers/bus') {
           mod = bus;
@@ -295,7 +297,6 @@ class WorkerFarm extends _events().default {
           throw new Error('No dynamic require possible: ' + location);
         }
       } else {
-        // $FlowFixMe this must be dynamic
         mod = require(location);
       }
     } else {
@@ -316,6 +317,7 @@ class WorkerFarm extends _events().default {
     let result;
     if (method == null) {
       try {
+        // @ts-expect-error TS2488
         result = responseFromContent(await mod(...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -326,7 +328,6 @@ class WorkerFarm extends _events().default {
         mod = mod.default;
       }
       try {
-        // $FlowFixMe
         result = responseFromContent(await mod[method](...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -481,6 +482,7 @@ class WorkerFarm extends _events().default {
     let filename = `profile-${getTimeId()}.trace`;
     let stream = trace.pipe(_fs().default.createWriteStream(filename));
     for (let profile of profiles) {
+      // @ts-expect-error TS2345
       trace.addCPUProfile(names.shift(), profile);
     }
     trace.flush();
@@ -543,7 +545,10 @@ class WorkerFarm extends _events().default {
     return _childState.child.workerApi;
   }
   static getConcurrentCallsPerWorker(defaultValue = DEFAULT_MAX_CONCURRENT_CALLS) {
-    return parseInt(process.env.ATLASPACK_MAX_CONCURRENT_CALLS, 10) || defaultValue;
+    return (
+      // @ts-expect-error TS2345
+      parseInt(process.env.ATLASPACK_MAX_CONCURRENT_CALLS, 10) || defaultValue
+    );
   }
 }
 exports.default = WorkerFarm;

package/lib/backend.js

@@ -5,8 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.detectBackend = detectBackend;
 exports.getWorkerBackend = getWorkerBackend;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 function detectBackend() {
-  // $FlowFixMe
+  // @ts-expect-error TS2339
   if (process.browser) return 'web';
   switch (process.env.ATLASPACK_WORKER_BACKEND) {
     case 'threads':

package/lib/bus.js

@@ -17,7 +17,7 @@ class Bus extends _events().default {
   emit(event, ...args) {
     if (_childState.child) {
       _childState.child.workerApi.callMaster({
-        // $FlowFixMe
+        // @ts-expect-error TS2339
         location: process.browser ? '@atlaspack/workers/bus' : __filename,
         method: 'emit',
         args: [event, ...args]

package/lib/child.js

@@ -51,6 +51,9 @@ var _Handle2 = _interopRequireDefault(require("./Handle"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
 // The import of './Handle' should really be imported eagerly (with @babel/plugin-transform-modules-commonjs's lazy mode).
 const Handle = _Handle2.default;
 class Child {
@@ -58,6 +61,7 @@ class Child {
   maxConcurrentCalls = 10;
   responseId = 0;
   responseQueue = new Map();
+  // @ts-expect-error TS2749
   handles = new Map();
   sharedReferences = new Map();
   sharedReferencesByValue = new Map();
@@ -78,7 +82,9 @@ class Child {
   }
   workerApi = {
     callMaster: (request, awaitResponse = true) => this.addCall(request, awaitResponse),
+    // @ts-expect-error TS2749
     createReverseHandle: fn => this.createReverseHandle(fn),
+    // @ts-expect-error TS2749
     runHandle: (handle, args) => this.workerApi.callMaster({
       handle: handle.id,
       args
@@ -97,7 +103,6 @@ class Child {
     this.child.send(data);
   }
   async childInit(module, childId) {
-    // $FlowFixMe
     this.module = require(module);
     this.childId = childId;
     if (this.module.childInit != null) {
@@ -189,7 +194,7 @@ class Child {
     } else {
       try {
         result = responseFromContent(
-        // $FlowFixMe
+        // @ts-expect-error TS2538
         await this.module[method](this.workerApi, ...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -222,12 +227,11 @@ class Child {
 
   // Keep in mind to make sure responses to these calls are JSON.Stringify safe
   addCall(request, awaitResponse = true) {
-    // $FlowFixMe
     let call = {
       ...request,
       type: 'request',
       child: this.childId,
-      // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
+      // @ts-expect-error TS2322
       awaitResponse,
       resolve: () => {},
       reject: () => {}
@@ -265,6 +269,7 @@ class Child {
       return;
     }
     if (this.responseQueue.size < this.maxConcurrentCalls) {
+      // @ts-expect-error TS2345
       this.sendRequest(this.callQueue.shift());
     }
   }
@@ -272,6 +277,8 @@ class Child {
     this.loggerDisposable.dispose();
     this.tracerDisposable.dispose();
   }
+
+  // @ts-expect-error TS2749
   createReverseHandle(fn) {
     let handle = new Handle({
       fn,

package/lib/cpuCount.js

@@ -50,18 +50,22 @@ function detectRealCores() {
   }
   return amount;
 }
+
+// @ts-expect-error TS7034
 let cores;
 function getCores(bypassCache = false) {
   // Do not re-run commands if we already have the count...
+  // @ts-expect-error TS7005
   if (cores && !bypassCache) {
     return cores;
   }
 
-  // $FlowFixMe
+  // @ts-expect-error TS2339
   if (process.browser) {
-    // eslint-disable-next-line no-undef
     cores = navigator.hardwareConcurrency / 2;
   }
+
+  // @ts-expect-error TS7005
   if (!cores) {
     try {
       cores = detectRealCores();

package/lib/process/ProcessChild.js

@@ -21,6 +21,7 @@ function _nullthrows() {
 var _child = require("../child");
 var _childState = require("../childState");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS2420
 class ProcessChild {
   constructor(onMessage, onExit) {
     if (!process.send) {
@@ -28,6 +29,7 @@ class ProcessChild {
     }
     this.onMessage = onMessage;
     this.onExit = onExit;
+    // @ts-expect-error TS2345
     process.on('message', data => this.handleMessage(data));
   }
   handleMessage(data) {
@@ -38,9 +40,10 @@ class ProcessChild {
   }
   send(data) {
     let processSend = (0, _nullthrows().default)(process.send).bind(process);
+    // @ts-expect-error TS7006
     processSend((0, _buildCache().serialize)(data).toString('base64'), err => {
       if (err && err instanceof Error) {
-        // $FlowFixMe[prop-missing]
+        // @ts-expect-error TS2339
         if (err.code === 'ERR_IPC_CHANNEL_CLOSED') {
           // IPC connection closed
           // no need to keep the worker running if it can't send or receive data
@@ -54,5 +57,7 @@ class ProcessChild {
     process.exit();
   }
 }
+
+// @ts-expect-error TS2345
 exports.default = ProcessChild;
 (0, _childState.setChild)(new _child.Child(ProcessChild));

package/lib/process/ProcessWorker.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _child_process() {
   const data = _interopRequireDefault(require("child_process"));
   _child_process = function () {
@@ -26,8 +26,15 @@ function _buildCache() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, './ProcessChild.js');
+let WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'ProcessChild.js');
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  exports.WORKER_PATH = WORKER_PATH = _path().default.join(__dirname, 'ProcessChild.ts');
+}
+
+// @ts-expect-error TS2420
 class ProcessWorker {
+  // @ts-expect-error TS2564
+
   processQueue = true;
   sendQueue = [];
   constructor(execArgv, onMessage, onError, onExit) {

package/lib/threads/ThreadsChild.js

@@ -28,6 +28,7 @@ function _nullthrows() {
 var _child = require("../child");
 var _childState = require("../childState");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS2420
 class ThreadsChild {
   constructor(onMessage, onExit) {
     if (_worker_threads().isMainThread || !_worker_threads().parentPort) {
@@ -45,5 +46,7 @@ class ThreadsChild {
     (0, _nullthrows().default)(_worker_threads().parentPort).postMessage((0, _buildCache().prepareForSerialization)(data));
   }
 }
+
+// @ts-expect-error TS2345
 exports.default = ThreadsChild;
 (0, _childState.setChild)(new _child.Child(ThreadsChild));

package/lib/threads/ThreadsWorker.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _worker_threads() {
   const data = require("worker_threads");
   _worker_threads = function () {
@@ -26,8 +26,15 @@ function _buildCache() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, './ThreadsChild.js');
+let WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'ThreadsChild.js');
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  exports.WORKER_PATH = WORKER_PATH = _path().default.join(__dirname, 'ThreadsChild.ts');
+}
+
+// @ts-expect-error TS2420
 class ThreadsWorker {
+  // @ts-expect-error TS2564
+
   constructor(execArgv, onMessage, onError, onExit) {
     this.execArgv = execArgv;
     this.onMessage = onMessage;
@@ -49,6 +56,7 @@ class ThreadsWorker {
   stop() {
     // In node 12, this returns a promise, but previously it accepted a callback
     // TODO: Pass a callback in earlier versions of Node
+    // @ts-expect-error TS2322
     return Promise.resolve(this.worker.terminate());
   }
   handleMessage(data) {

package/lib/types/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/types/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 {};