@parcel/workers 2.0.0-nightly.97 → 2.1.0

package/index.d.ts

@@ -0,0 +1,22 @@
+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,
+};
+
+declare class WorkerFarm {
+  constructor(options: FarmOptions);
+
+  end(): Promise<void>;
+}
+
+export default WorkerFarm; 

package/lib/Handle.js

@@ -5,33 +5,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _core = require("@parcel/core");
+function _core() {
+  const data = require("@parcel/core");
 
-var _childState = require("./childState");
+  _core = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _package = _interopRequireDefault(require("../package.json"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+// $FlowFixMe
+let HANDLE_ID = 0; // $FlowFixMe
 
-let HANDLE_ID = 0;
 const handleById = new Map();
 
 class Handle {
   constructor(opts) {
-    _defineProperty(this, "id", void 0);
-
-    _defineProperty(this, "childId", void 0);
-
-    _defineProperty(this, "fn", void 0);
+    var _opts$id;
 
-    _defineProperty(this, "workerApi", void 0);
-
-    this.id = ++HANDLE_ID;
+    this.id = (_opts$id = opts.id) !== null && _opts$id !== void 0 ? _opts$id : ++HANDLE_ID;
     this.fn = opts.fn;
     this.childId = opts.childId;
-    this.workerApi = opts.workerApi;
     handleById.set(this.id, this);
   }
 
@@ -47,37 +46,7 @@ class Handle {
   }
 
   static deserialize(opts) {
-    return function (...args) {
-      let workerApi;
-
-      if (_childState.child) {
-        workerApi = _childState.child.workerApi;
-      } else {
-        let handle = handleById.get(opts.id);
-
-        if (!handle) {
-          throw new Error('Corresponding Handle was not found. It may have been disposed.');
-        }
-
-        workerApi = handle.workerApi;
-      }
-
-      if (opts.childId != null && _childState.child) {
-        throw new Error('Cannot call another child from a child');
-      }
-
-      if (opts.childId != null && workerApi.callChild) {
-        return workerApi.callChild(opts.childId, {
-          handle: opts.id,
-          args
-        });
-      }
-
-      return workerApi.callMaster({
-        handle: opts.id,
-        args
-      }, true);
-    };
+    return new Handle(opts);
   }
 
 } // Register the Handle as a serializable class so that it will properly be deserialized
@@ -85,4 +54,4 @@ class Handle {
 
 
 exports.default = Handle;
-(0, _core.registerSerializableClass)(`${_package.default.version}:Handle`, Handle);
+(0, _core().registerSerializableClass)(`${_package.default.version}:Handle`, Handle);

package/lib/Profiler.js

@@ -5,26 +5,36 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _assert = _interopRequireDefault(require("assert"));
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
 
-var _diagnostic = _interopRequireDefault(require("@parcel/diagnostic"));
+  _assert = function () {
+    return data;
+  };
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  return data;
+}
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@parcel/diagnostic"));
 
-class Profiler {
-  constructor() {
-    _defineProperty(this, "session", void 0);
-  }
+  _diagnostic = function () {
+    return data;
+  };
 
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Profiler {
   startProfiling() {
     let inspector;
 
     try {
       inspector = require('inspector');
     } catch (err) {
-      throw new _diagnostic.default({
+      throw new (_diagnostic().default)({
         diagnostic: {
           message: `The inspector module isn't available`,
           origin: '@parcel/workers',
@@ -41,7 +51,7 @@ class Profiler {
   }
 
   sendCommand(method, params) {
-    (0, _assert.default)(this.session != null);
+    (0, _assert().default)(this.session != null);
     return new Promise((resolve, reject) => {
       this.session.post(method, params, (err, params) => {
         if (err == null) {

package/lib/Trace.js

@@ -5,32 +5,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _chromeTraceEvent = require("chrome-trace-event");
+function _chromeTraceEvent() {
+  const data = require("chrome-trace-event");
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  _chromeTraceEvent = function () {
+    return data;
+  };
+
+  return data;
+}
 
 class Trace {
   constructor() {
-    _defineProperty(this, "tracer", void 0);
-
-    _defineProperty(this, "tid", void 0);
-
-    _defineProperty(this, "eventId", void 0);
-
-    this.tracer = new _chromeTraceEvent.Tracer();
+    this.tracer = new (_chromeTraceEvent().Tracer)();
     this.tid = 0;
     this.eventId = 0;
-    this.init();
   }
 
   getEventId() {
     return this.eventId++;
   }
 
-  init() {
+  init(ts) {
     this.tracer.instantEvent({
       name: 'TracingStartedInPage',
       id: this.getEventId(),
+      ts,
       cat: ['disabled-by-default-devtools.timeline'],
       args: {
         data: {
@@ -47,6 +47,7 @@ class Trace {
     this.tracer.instantEvent({
       name: 'TracingStartedInBrowser',
       id: this.getEventId(),
+      ts,
       cat: ['disabled-by-default-devtools.timeline'],
       args: {
         data: {
@@ -57,6 +58,10 @@ class Trace {
   }
 
   addCPUProfile(name, profile) {
+    if (this.eventId === 0) {
+      this.init(profile.startTime);
+    }
+
     const trace = this.tracer;
     const tid = this.tid;
     this.tid++;

package/lib/Worker.js

@@ -5,45 +5,59 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _events = _interopRequireDefault(require("events"));
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
 
-var _diagnostic = _interopRequireDefault(require("@parcel/diagnostic"));
+  _nullthrows = function () {
+    return data;
+  };
 
-var _backend = require("./backend");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-let WORKER_ID = 0;
+  return data;
+}
 
-class Worker extends _events.default {
-  constructor(options) {
-    super();
+function _events() {
+  const data = _interopRequireDefault(require("events"));
 
-    _defineProperty(this, "options", void 0);
+  _events = function () {
+    return data;
+  };
 
-    _defineProperty(this, "worker", void 0);
+  return data;
+}
 
-    _defineProperty(this, "id", WORKER_ID++);
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@parcel/diagnostic"));
 
-    _defineProperty(this, "calls", new Map());
+  _diagnostic = function () {
+    return data;
+  };
 
-    _defineProperty(this, "exitCode", null);
+  return data;
+}
 
-    _defineProperty(this, "callId", 0);
+var _backend = require("./backend");
 
-    _defineProperty(this, "ready", false);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-    _defineProperty(this, "stopped", false);
+let WORKER_ID = 0;
 
-    _defineProperty(this, "isStopping", false);
+class Worker extends _events().default {
+  id = WORKER_ID++;
+  sharedReferences = new Map();
+  calls = new Map();
+  exitCode = null;
+  callId = 0;
+  ready = false;
+  stopped = false;
+  isStopping = false;
 
+  constructor(options) {
+    super();
     this.options = options;
   }
 
   async fork(forkModule) {
-    let filteredArgs = process.execArgv.filter(v => !/^--(debug|inspect)/.test(v));
+    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];
@@ -52,6 +66,32 @@ class Worker extends _events.default {
         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 WorkerBackend = (0, _backend.getWorkerBackend)(this.options.backend);
@@ -66,17 +106,41 @@ class Worker extends _events.default {
       this.call({
         method: 'childInit',
         args: [forkModule, {
-          patchConsole: !!this.options.patchConsole
+          shouldPatchConsole: !!this.options.shouldPatchConsole
         }],
         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].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) {
+    return new Promise((resolve, reject) => {
+      this.call({
+        method: 'createSharedReference',
+        args: [ref, value],
+        resolve,
+        reject,
+        retries: 0,
+        skipReadyCheck: true
+      });
+    });
+  }
+
   send(data) {
     this.worker.send(data);
   }
@@ -88,14 +152,20 @@ class Worker extends _events.default {
 
     let idx = this.callId++;
     this.calls.set(idx, call);
-    this.send({
+    let msg = {
       type: 'request',
       idx: idx,
       child: this.id,
       handle: call.handle,
       method: call.method,
       args: call.args
-    });
+    };
+
+    if (this.ready || call.skipReadyCheck === true) {
+      this.send(msg);
+    } else {
+      this.once('ready', () => this.send(msg));
+    }
   }
 
   receive(message) {
@@ -120,7 +190,7 @@ class Worker extends _events.default {
       }
 
       if (message.contentType === 'error') {
-        call.reject(new _diagnostic.default({
+        call.reject(new (_diagnostic().default)({
           diagnostic: message.content
         }));
       } else {