@parcel/workers 2.8.3 → 2.9.0

package/index.d.ts

@@ -3,14 +3,15 @@ import {FilePath} from '@parcel/types';
 type BackendType = 'process' | 'threads';
 
 export type FarmOptions = {
-  maxConcurrentWorkers: number,
-  maxConcurrentCallsPerWorker: number,
-  forcedKillTime: number,
-  useLocalWorker: boolean,
-  warmWorkers: boolean,
-  workerPath?: FilePath,
-  backend: BackendType,
-  shouldPatchConsole?: boolean,
+  maxConcurrentWorkers: number;
+  maxConcurrentCallsPerWorker: number;
+  forcedKillTime: number;
+  useLocalWorker: boolean;
+  warmWorkers: boolean;
+  workerPath?: FilePath;
+  backend: BackendType;
+  shouldPatchConsole?: boolean;
+  shouldTrace?: boolean;
 };
 
 declare class WorkerFarm {
@@ -19,4 +20,4 @@ declare class WorkerFarm {
   end(): Promise<void>;
 }
 
-export default WorkerFarm; 
+export default WorkerFarm;

package/lib/Handle.js

@@ -4,54 +4,43 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _core() {
   const data = require("@parcel/core");
-
   _core = function () {
     return data;
   };
-
   return data;
 }
-
 var _package = _interopRequireDefault(require("../package.json"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 // $FlowFixMe
-let HANDLE_ID = 0; // $FlowFixMe
+let HANDLE_ID = 0;
+// $FlowFixMe
 
 const handleById = new Map();
-
 class Handle {
   constructor(opts) {
     var _opts$id;
-
     this.id = (_opts$id = opts.id) !== null && _opts$id !== void 0 ? _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
+// Register the Handle as a serializable class so that it will properly be deserialized
 // by anything that uses WorkerFarm.
-
-
 exports.default = Handle;
 (0, _core().registerSerializableClass)(`${_package.default.version}:Handle`, Handle);

package/lib/Worker.js

@@ -4,43 +4,30 @@ 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("@parcel/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 {
   id = WORKER_ID++;
   sentSharedReferences = new Set();
@@ -50,31 +37,26 @@ class Worker extends _events().default {
   ready = false;
   stopped = false;
   isStopping = false;
-
   constructor(options) {
     super();
     this.options = options;
   }
-
   async fork(forkModule) {
     let filteredArgs = process.execArgv.filter(v => !/^--(debug|inspect|max-old-space-size=)/.test(v));
-
     for (let i = 0; i < filteredArgs.length; i++) {
       let arg = filteredArgs[i];
       let isArgWithParam = (arg === '-r' || arg === '--require') && filteredArgs[i + 1] === '@parcel/register' || arg === '--title';
-
       if (isArgWithParam) {
         filteredArgs.splice(i, 2);
         i--;
       }
-    } // Workaround for https://github.com/nodejs/node/issues/29117
-
+    }
 
+    // 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;
@@ -84,17 +66,14 @@ class Worker extends _events().default {
           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 WorkerBackend = (0, _backend.getWorkerBackend)(this.options.backend);
     this.worker = new WorkerBackend(filteredArgs, data => this.receive(data), err => {
       this.emit('error', err);
@@ -107,7 +86,8 @@ class Worker extends _events().default {
       this.call({
         method: 'childInit',
         args: [forkModule, {
-          shouldPatchConsole: !!this.options.shouldPatchConsole
+          shouldPatchConsole: !!this.options.shouldPatchConsole,
+          shouldTrace: !!this.options.shouldTrace
         }],
         retries: 0,
         skipReadyCheck: true,
@@ -116,19 +96,17 @@ class Worker extends _events().default {
       });
     });
     let sharedRefs = this.options.sharedReferences;
-    let refsShared = new Set(); // in case more refs are created while initial refs are sending
-
+    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 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) => {
@@ -142,16 +120,13 @@ class Worker extends _events().default {
       });
     });
   }
-
   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 = {
@@ -162,35 +137,28 @@ class Worker extends _events().default {
       method: call.method,
       args: call.args
     };
-
     if (this.ready || call.skipReadyCheck === true) {
       this.send(msg);
     } else {
       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
@@ -198,22 +166,17 @@ class Worker extends _events().default {
       } 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;