@parcel/workers 2.8.4-nightly.0 → 2.9.1

package/lib/WorkerFarm.js

@@ -10,108 +10,77 @@ Object.defineProperty(exports, "Handle", {
   }
 });
 exports.default = void 0;
-
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
-
   _assert = function () {
     return data;
   };
-
   return data;
 }
-
 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 _core() {
   const data = require("@parcel/core");
-
   _core = function () {
     return data;
   };
-
   return data;
 }
-
 function _diagnostic() {
   const data = _interopRequireWildcard(require("@parcel/diagnostic"));
-
   _diagnostic = function () {
     return data;
   };
-
   return data;
 }
-
 var _Worker = _interopRequireDefault(require("./Worker"));
-
 var _cpuCount = _interopRequireDefault(require("./cpuCount"));
-
 var _Handle = _interopRequireDefault(require("./Handle"));
-
 var _childState = require("./childState");
-
 var _backend = require("./backend");
-
 function _profiler() {
   const data = require("@parcel/profiler");
-
   _profiler = function () {
     return data;
   };
-
   return data;
 }
-
 function _fs() {
   const data = _interopRequireDefault(require("fs"));
-
   _fs = function () {
     return data;
   };
-
   return data;
 }
-
 function _logger() {
   const data = _interopRequireDefault(require("@parcel/logger"));
-
   _logger = function () {
     return data;
   };
-
   return data;
 }
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 let referenceId = 1;
+const DEFAULT_MAX_CONCURRENT_CALLS = 30;
 
 /**
  * workerPath should always be defined inside farmOptions
  */
+
 class WorkerFarm extends _events().default {
   callQueue = [];
   ending = false;
@@ -121,12 +90,11 @@ class WorkerFarm extends _events().default {
   sharedReferences = new Map();
   sharedReferencesByValue = new Map();
   serializedSharedReferences = new Map();
-
   constructor(farmOptions = {}) {
     super();
     this.options = {
       maxConcurrentWorkers: WorkerFarm.getNumWorkers(),
-      maxConcurrentCallsPerWorker: WorkerFarm.getConcurrentCallsPerWorker(),
+      maxConcurrentCallsPerWorker: WorkerFarm.getConcurrentCallsPerWorker(farmOptions.shouldTrace ? 1 : DEFAULT_MAX_CONCURRENT_CALLS),
       forcedKillTime: 500,
       warmWorkers: false,
       useLocalWorker: true,
@@ -134,15 +102,16 @@ class WorkerFarm extends _events().default {
       backend: (0, _backend.detectBackend)(),
       ...farmOptions
     };
-
     if (!this.options.workerPath) {
       throw new Error('Please provide a worker path!');
-    } // $FlowFixMe this must be dynamic
-
+    }
 
+    // $FlowFixMe this must be dynamic
     this.localWorker = require(this.options.workerPath);
     this.localWorkerInit = this.localWorker.childInit != null ? this.localWorker.childInit() : null;
-    this.run = this.createHandle('run'); // Worker thread stdout is by default piped into the process stdout, if there are enough worker
+    this.run = this.createHandle('run');
+
+    // Worker thread stdout is by default piped into the process stdout, if there are enough worker
     // threads to exceed the default listener limit, then anything else piping into stdout will trigger
     // the `MaxListenersExceededWarning`, so we should ensure the max listeners is at least equal to the
     // number of workers + 1 for the main thread.
@@ -150,22 +119,22 @@ class WorkerFarm extends _events().default {
     // Note this can't be fixed easily where other things pipe into stdout -  even after starting > 10 worker
     // threads `process.stdout.getMaxListeners()` will still return 10, however adding another pipe into `stdout`
     // will give the warning with `<worker count + 1>` as the number of listeners.
-
     process.stdout.setMaxListeners(Math.max(process.stdout.getMaxListeners(), WorkerFarm.getNumWorkers() + 1));
     this.startMaxWorkers();
   }
-
   workerApi = {
     callMaster: async (request, awaitResponse = true) => {
       // $FlowFixMe
-      let result = await this.processRequest({ ...request,
+      let result = await this.processRequest({
+        ...request,
         awaitResponse
       });
       return (0, _core().deserialize)((0, _core().serialize)(result));
     },
     createReverseHandle: fn => this.createReverseHandle(fn),
     callChild: (childId, request) => new Promise((resolve, reject) => {
-      (0, _nullthrows().default)(this.workers.get(childId)).call({ ...request,
+      (0, _nullthrows().default)(this.workers.get(childId)).call({
+        ...request,
         resolve,
         reject,
         retries: 0
@@ -178,38 +147,32 @@ class WorkerFarm extends _events().default {
     getSharedReference: ref => this.sharedReferences.get(ref),
     resolveSharedReference: value => this.sharedReferencesByValue.get(value)
   };
-
   warmupWorker(method, args) {
     // Workers are already stopping
     if (this.ending) {
       return;
-    } // Workers are not warmed up yet.
+    }
+
+    // Workers are not warmed up yet.
     // Send the job to a remote worker in the background,
     // but use the result from the local worker - it will be faster.
-
-
     let promise = this.addCall(method, [...args, true]);
-
     if (promise) {
       promise.then(() => {
         this.warmWorkers++;
-
         if (this.warmWorkers >= this.workers.size) {
           this.emit('warmedup');
         }
       }).catch(() => {});
     }
   }
-
   shouldStartRemoteWorkers() {
     return this.options.maxConcurrentWorkers > 0 || !this.options.useLocalWorker;
   }
-
   createHandle(method, useMainThread = false) {
     if (!this.options.useLocalWorker) {
       useMainThread = false;
     }
-
     return async (...args) => {
       // Child process workers are slow to start (~600ms).
       // While we're waiting, just run on the main thread.
@@ -220,25 +183,20 @@ class WorkerFarm extends _events().default {
         if (this.options.warmWorkers && this.shouldStartRemoteWorkers()) {
           this.warmupWorker(method, args);
         }
-
         let processedArgs;
-
         if (!useMainThread) {
           processedArgs = (0, _core().restoreDeserializedObject)((0, _core().prepareForSerialization)([...args, false]));
         } else {
           processedArgs = args;
         }
-
         if (this.localWorkerInit != null) {
           await this.localWorkerInit;
           this.localWorkerInit = null;
         }
-
         return this.localWorker[method](this.workerApi, ...processedArgs);
       }
     };
   }
-
   onError(error, worker) {
     // Handle ipc errors
     if (error.code === 'ERR_IPC_CHANNEL_CLOSED') {
@@ -247,7 +205,6 @@ class WorkerFarm extends _events().default {
       _logger().default.error(error, '@parcel/workers');
     }
   }
-
   startChild() {
     let worker = new _Worker.default({
       forcedKillTime: this.options.forcedKillTime,
@@ -264,60 +221,49 @@ class WorkerFarm extends _events().default {
     worker.once('exit', () => this.stopWorker(worker));
     this.workers.set(worker.id, worker);
   }
-
   async stopWorker(worker) {
     if (!worker.stopped) {
       this.workers.delete(worker.id);
       worker.isStopping = true;
-
       if (worker.calls.size) {
         for (let call of worker.calls.values()) {
           call.retries++;
           this.callQueue.unshift(call);
         }
       }
-
       worker.calls.clear();
-      await worker.stop(); // Process any requests that failed and start a new worker
+      await worker.stop();
 
+      // Process any requests that failed and start a new worker
       this.processQueue();
     }
   }
-
   processQueue() {
     if (this.ending || !this.callQueue.length) return;
-
     if (this.workers.size < this.options.maxConcurrentWorkers) {
       this.startChild();
     }
-
     let workers = [...this.workers.values()].sort((a, b) => a.calls.size - b.calls.size);
-
     for (let worker of workers) {
       if (!this.callQueue.length) {
         break;
       }
-
       if (!worker.ready || worker.stopped || worker.isStopping) {
         continue;
       }
-
       if (worker.calls.size < this.options.maxConcurrentCallsPerWorker) {
         this.callWorker(worker, this.callQueue.shift());
       }
     }
   }
-
   async callWorker(worker, call) {
     for (let ref of this.sharedReferences.keys()) {
       if (!worker.sentSharedReferences.has(ref)) {
         await worker.sendSharedReference(ref, this.getSerializedSharedReference(ref));
       }
     }
-
     worker.call(call);
   }
-
   async processRequest(data, worker) {
     let {
       method,
@@ -328,10 +274,8 @@ class WorkerFarm extends _events().default {
       handle: handleId
     } = data;
     let mod;
-
     if (handleId != null) {
       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 this must be dynamic
@@ -339,23 +283,19 @@ class WorkerFarm extends _events().default {
     } else {
       throw new Error('Unknown request');
     }
-
     const responseFromContent = content => ({
       idx,
       type: 'response',
       contentType: 'data',
       content
     });
-
     const errorResponseFromError = e => ({
       idx,
       type: 'response',
       contentType: 'error',
       content: (0, _diagnostic().anyToDiagnostic)(e)
     });
-
     let result;
-
     if (method == null) {
       try {
         result = responseFromContent(await mod(...args));
@@ -367,7 +307,6 @@ class WorkerFarm extends _events().default {
       if (mod.__esModule && !mod[method] && mod.default) {
         mod = mod.default;
       }
-
       try {
         // $FlowFixMe
         result = responseFromContent(await mod[method](...args));
@@ -375,7 +314,6 @@ class WorkerFarm extends _events().default {
         result = errorResponseFromError(e);
       }
     }
-
     if (awaitResponse) {
       if (worker) {
         worker.send(result);
@@ -385,17 +323,14 @@ class WorkerFarm extends _events().default {
             diagnostic: result.content
           });
         }
-
         return result.content;
       }
     }
   }
-
   addCall(method, args) {
     if (this.ending) {
       throw new Error('Cannot add a worker call if workerfarm is ending.');
     }
-
     return new Promise((resolve, reject) => {
       this.callQueue.push({
         method,
@@ -407,36 +342,29 @@ class WorkerFarm extends _events().default {
       this.processQueue();
     });
   }
-
   async end() {
     this.ending = true;
     await Promise.all(Array.from(this.workers.values()).map(worker => this.stopWorker(worker)));
-
     for (let handle of this.handles.values()) {
       handle.dispose();
     }
-
     this.handles = new Map();
     this.sharedReferences = new Map();
     this.sharedReferencesByValue = new Map();
     this.ending = false;
   }
-
   startMaxWorkers() {
     // Starts workers until the maximum is reached
     if (this.workers.size < this.options.maxConcurrentWorkers) {
       let toStart = this.options.maxConcurrentWorkers - this.workers.size;
-
       while (toStart--) {
         this.startChild();
       }
     }
   }
-
   shouldUseRemoteWorkers() {
     return !this.options.useLocalWorker || (this.warmWorkers >= this.workers.size || !this.options.warmWorkers) && this.options.maxConcurrentWorkers > 0;
   }
-
   createReverseHandle(fn) {
     let handle = new _Handle.default({
       fn
@@ -444,16 +372,13 @@ class WorkerFarm extends _events().default {
     this.handles.set(handle.id, handle);
     return handle;
   }
-
   createSharedReference(value, isCacheable = true) {
     let ref = referenceId++;
     this.sharedReferences.set(ref, value);
     this.sharedReferencesByValue.set(value, ref);
-
     if (!isCacheable) {
       this.serializedSharedReferences.set(ref, null);
     }
-
     return {
       ref,
       dispose: () => {
@@ -461,12 +386,10 @@ class WorkerFarm extends _events().default {
         this.sharedReferencesByValue.delete(value);
         this.serializedSharedReferences.delete(ref);
         let promises = [];
-
         for (let worker of this.workers.values()) {
           if (!worker.sentSharedReferences.has(ref)) {
             continue;
           }
-
           worker.sentSharedReferences.delete(ref);
           promises.push(new Promise((resolve, reject) => {
             worker.call({
@@ -479,33 +402,27 @@ class WorkerFarm extends _events().default {
             });
           }));
         }
-
         return Promise.all(promises);
       }
     };
   }
-
   getSerializedSharedReference(ref) {
     let cached = this.serializedSharedReferences.get(ref);
-
     if (cached) {
       return cached;
     }
-
     let value = this.sharedReferences.get(ref);
-    let buf = (0, _core().serialize)(value).buffer; // If the reference was created with the isCacheable option set to false,
-    // serializedSharedReferences will contain `null` as the value.
+    let buf = (0, _core().serialize)(value).buffer;
 
+    // If the reference was created with the isCacheable option set to false,
+    // serializedSharedReferences will contain `null` as the value.
     if (cached !== null) {
       this.serializedSharedReferences.set(ref, buf);
     }
-
     return buf;
   }
-
   async startProfile() {
     let promises = [];
-
     for (let worker of this.workers.values()) {
       promises.push(new Promise((resolve, reject) => {
         worker.call({
@@ -518,20 +435,16 @@ class WorkerFarm extends _events().default {
         });
       }));
     }
-
     this.profiler = new (_profiler().SamplingProfiler)();
     promises.push(this.profiler.startProfiling());
     await Promise.all(promises);
   }
-
   async endProfile() {
     if (!this.profiler) {
       return;
     }
-
     let promises = [this.profiler.stopProfiling()];
     let names = ['Master'];
-
     for (let worker of this.workers.values()) {
       names.push('Worker ' + worker.id);
       promises.push(new Promise((resolve, reject) => {
@@ -545,30 +458,24 @@ class WorkerFarm extends _events().default {
         });
       }));
     }
-
     var profiles = await Promise.all(promises);
     let trace = new (_profiler().Trace)();
     let filename = `profile-${getTimeId()}.trace`;
     let stream = trace.pipe(_fs().default.createWriteStream(filename));
-
     for (let profile of profiles) {
       trace.addCPUProfile(names.shift(), profile);
     }
-
     trace.flush();
     await new Promise(resolve => {
       stream.once('finish', resolve);
     });
-
     _logger().default.info({
       origin: '@parcel/workers',
       message: (0, _diagnostic().md)`Wrote profile to ${filename}`
     });
   }
-
   async callAllWorkers(method, args) {
     let promises = [];
-
     for (let worker of this.workers.values()) {
       promises.push(new Promise((resolve, reject) => {
         worker.call({
@@ -580,14 +487,11 @@ class WorkerFarm extends _events().default {
         });
       }));
     }
-
     promises.push(this.localWorker[method](this.workerApi, ...args));
     await Promise.all(promises);
   }
-
   async takeHeapSnapshot() {
     let snapshotId = getTimeId();
-
     try {
       let snapshotPaths = await Promise.all([...this.workers.values()].map(worker => new Promise((resolve, reject) => {
         worker.call({
@@ -599,7 +503,6 @@ class WorkerFarm extends _events().default {
           skipReadyCheck: true
         });
       })));
-
       _logger().default.info({
         origin: '@parcel/workers',
         message: (0, _diagnostic().md)`Wrote heap snapshots to the following paths:\n${snapshotPaths.join('\n')}`
@@ -611,28 +514,21 @@ class WorkerFarm extends _events().default {
       });
     }
   }
-
   static getNumWorkers() {
     return process.env.PARCEL_WORKERS ? parseInt(process.env.PARCEL_WORKERS, 10) : Math.ceil((0, _cpuCount.default)() / 2);
   }
-
   static isWorker() {
     return !!_childState.child;
   }
-
   static getWorkerApi() {
     (0, _assert().default)(_childState.child != null, 'WorkerFarm.getWorkerApi can only be called within workers');
     return _childState.child.workerApi;
   }
-
-  static getConcurrentCallsPerWorker() {
-    return parseInt(process.env.PARCEL_MAX_CONCURRENT_CALLS, 10) || 30;
+  static getConcurrentCallsPerWorker(defaultValue = DEFAULT_MAX_CONCURRENT_CALLS) {
+    return parseInt(process.env.PARCEL_MAX_CONCURRENT_CALLS, 10) || defaultValue;
   }
-
 }
-
 exports.default = WorkerFarm;
-
 function getTimeId() {
   let now = new Date();
   return String(now.getFullYear()) + String(now.getMonth() + 1).padStart(2, '0') + String(now.getDate()).padStart(2, '0') + '-' + String(now.getHours()).padStart(2, '0') + String(now.getMinutes()).padStart(2, '0') + String(now.getSeconds()).padStart(2, '0');

package/lib/backend.js

@@ -5,31 +5,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.detectBackend = detectBackend;
 exports.getWorkerBackend = getWorkerBackend;
-
 function detectBackend() {
   switch (process.env.PARCEL_WORKER_BACKEND) {
     case 'threads':
     case 'process':
       return process.env.PARCEL_WORKER_BACKEND;
   }
-
   try {
     require('worker_threads');
-
     return 'threads';
   } catch (err) {
     return 'process';
   }
 }
-
 function getWorkerBackend(backend) {
   switch (backend) {
     case 'threads':
       return require('./threads/ThreadsWorker').default;
-
     case 'process':
       return require('./process/ProcessWorker').default;
-
     default:
       throw new Error(`Invalid backend: ${backend}`);
   }

package/lib/bus.js

@@ -4,21 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _events() {
   const data = _interopRequireDefault(require("events"));
-
   _events = function () {
     return data;
   };
-
   return data;
 }
-
 var _childState = require("./childState");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 class Bus extends _events().default {
   emit(event, ...args) {
     if (_childState.child) {
@@ -27,15 +21,11 @@ class Bus extends _events().default {
         method: 'emit',
         args: [event, ...args]
       }, false);
-
       return true;
     } else {
       return super.emit(event, ...args);
     }
   }
-
 }
-
 var _default = new Bus();
-
 exports.default = _default;