@parcel/workers 2.0.0-beta.3 → 2.0.0-dev.1510

package/src/web/WebWorker.js

@@ -0,0 +1,85 @@
+// @flow
+
+import type {
+  WorkerImpl,
+  MessageHandler,
+  ErrorHandler,
+  ExitHandler,
+  WorkerMessage,
+} from '../types';
+import {prepareForSerialization, restoreDeserializedObject} from '@parcel/core';
+import {makeDeferredWithPromise} from '@parcel/utils';
+
+let id = 0;
+
+export default class WebWorker implements WorkerImpl {
+  execArgv: Object;
+  onMessage: MessageHandler;
+  onError: ErrorHandler;
+  onExit: ExitHandler;
+  worker: Worker;
+  stopping: ?Promise<void>;
+
+  constructor(
+    execArgv: Object,
+    onMessage: MessageHandler,
+    onError: ErrorHandler,
+    onExit: ExitHandler,
+  ) {
+    this.execArgv = execArgv;
+    this.onMessage = onMessage;
+    this.onError = onError;
+    this.onExit = onExit;
+  }
+
+  start(): Promise<void> {
+    // $FlowFixMe[incompatible-call]
+    this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
+      name: `Parcel Worker ${id++}`,
+      type: 'module',
+    });
+
+    let {deferred, promise} = makeDeferredWithPromise();
+
+    this.worker.onmessage = ({data}) => {
+      if (data === 'online') {
+        deferred.resolve();
+        return;
+      }
+
+      // $FlowFixMe assume WorkerMessage as data
+      this.handleMessage(data);
+    };
+    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);
+
+    return promise;
+  }
+
+  stop(): Promise<void> {
+    if (!this.stopping) {
+      this.stopping = (async () => {
+        this.worker.postMessage('stop');
+        let {deferred, promise} = makeDeferredWithPromise();
+        this.worker.addEventListener('message', ({data}: MessageEvent) => {
+          if (data === 'stopped') {
+            deferred.resolve();
+          }
+        });
+        await promise;
+        this.worker.terminate();
+        this.onExit(0);
+      })();
+    }
+    return this.stopping;
+  }
+
+  handleMessage(data: WorkerMessage) {
+    this.onMessage(restoreDeserializedObject(data));
+  }
+
+  send(data: WorkerMessage) {
+    this.worker.postMessage(prepareForSerialization(data));
+  }
+}

package/test/cpuCount.test.js

@@ -3,7 +3,7 @@ import os from 'os';
 
 import getCores, {detectRealCores} from '../src/cpuCount';
 
-describe('cpuCount', function() {
+describe('cpuCount', function () {
   it('Should be able to detect real cpu count', () => {
     // Windows not supported as getting the cpu count takes a couple seconds...
     if (os.platform() === 'win32') return;

package/test/workerfarm.js

@@ -2,7 +2,7 @@ import Logger from '@parcel/logger';
 import assert from 'assert';
 import WorkerFarm from '../src';
 
-describe('WorkerFarm', function() {
+describe('WorkerFarm', function () {
   this.timeout(30000);
 
   it('Should start up workers', async () => {

package/lib/Profiler.js

@@ -1,86 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-
-  _assert = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@parcel/diagnostic"));
-
-  _diagnostic = function () {
-    return data;
-  };
-
-  return data;
-}
-
-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; }
-
-class Profiler {
-  constructor() {
-    _defineProperty(this, "session", void 0);
-  }
-
-  startProfiling() {
-    let inspector;
-
-    try {
-      inspector = require('inspector');
-    } catch (err) {
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: `The inspector module isn't available`,
-          origin: '@parcel/workers',
-          hints: ['Disable build profiling']
-        }
-      });
-    }
-
-    this.session = new inspector.Session();
-    this.session.connect();
-    return Promise.all([this.sendCommand('Profiler.setSamplingInterval', {
-      interval: 100
-    }), this.sendCommand('Profiler.enable'), this.sendCommand('Profiler.start')]);
-  }
-
-  sendCommand(method, params) {
-    (0, _assert().default)(this.session != null);
-    return new Promise((resolve, reject) => {
-      this.session.post(method, params, (err, params) => {
-        if (err == null) {
-          resolve(params);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-
-  destroy() {
-    if (this.session != null) {
-      this.session.disconnect();
-    }
-  }
-
-  async stopProfiling() {
-    let res = await this.sendCommand('Profiler.stop');
-    this.destroy();
-    return res.profile;
-  }
-
-}
-
-exports.default = Profiler;

package/lib/Trace.js

@@ -1,139 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-function _chromeTraceEvent() {
-  const data = require("chrome-trace-event");
-
-  _chromeTraceEvent = function () {
-    return data;
-  };
-
-  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; }
-
-class Trace {
-  constructor() {
-    _defineProperty(this, "tracer", void 0);
-
-    _defineProperty(this, "tid", void 0);
-
-    _defineProperty(this, "eventId", void 0);
-
-    this.tracer = new (_chromeTraceEvent().Tracer)();
-    this.tid = 0;
-    this.eventId = 0;
-  }
-
-  getEventId() {
-    return this.eventId++;
-  }
-
-  init(ts) {
-    this.tracer.instantEvent({
-      name: 'TracingStartedInPage',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1',
-          page: '0xfff',
-          frames: [{
-            frame: '0xfff',
-            url: 'parcel',
-            name: ''
-          }]
-        }
-      }
-    });
-    this.tracer.instantEvent({
-      name: 'TracingStartedInBrowser',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1'
-        }
-      }
-    });
-  }
-
-  addCPUProfile(name, profile) {
-    if (this.eventId === 0) {
-      this.init(profile.startTime);
-    }
-
-    const trace = this.tracer;
-    const tid = this.tid;
-    this.tid++;
-    const cpuStartTime = profile.startTime;
-    const cpuEndTime = profile.endTime;
-    trace.instantEvent({
-      tid,
-      id: this.getEventId(),
-      cat: ['toplevel'],
-      name: 'TaskQueueManager::ProcessTaskFromWorkQueue',
-      args: {
-        src_file: '../../ipc/ipc_moji_bootstrap.cc',
-        src_func: 'Accept'
-      },
-      ts: cpuStartTime
-    });
-    trace.completeEvent({
-      tid,
-      name: 'EvaluateScript',
-      id: this.getEventId(),
-      cat: ['devtools.timeline'],
-      ts: cpuStartTime,
-      dur: cpuEndTime - cpuStartTime,
-      args: {
-        data: {
-          url: 'parcel',
-          lineNumber: 1,
-          columnNumber: 1,
-          frame: '0xFFF'
-        }
-      }
-    });
-    trace.instantEvent({
-      tid,
-      ts: 0,
-      ph: 'M',
-      cat: ['__metadata'],
-      name: 'thread_name',
-      args: {
-        name
-      }
-    });
-    trace.instantEvent({
-      tid,
-      name: 'CpuProfile',
-      id: this.getEventId(),
-      cat: ['disabled-by-default-devtools.timeline'],
-      ts: cpuEndTime,
-      args: {
-        data: {
-          cpuProfile: profile
-        }
-      }
-    });
-  }
-
-  pipe(writable) {
-    return this.tracer.pipe(writable);
-  }
-
-  flush() {
-    this.tracer.push(null);
-  }
-
-}
-
-exports.default = Trace;

package/src/Profiler.js

@@ -1,93 +0,0 @@
-// @flow
-import type {Session} from 'inspector';
-import invariant from 'assert';
-import ThrowableDiagnostic from '@parcel/diagnostic';
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-Profile
-export type Profile = {|
-  nodes: Array<ProfileNode>,
-  startTime: number,
-  endTime: number,
-  samples?: Array<number>,
-  timeDeltas?: Array<number>,
-|};
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ProfileNode
-type ProfileNode = {|
-  id: number,
-  callFrame: CallFrame,
-  hitCount?: number,
-  children?: Array<number>,
-  deoptReason?: string,
-  positionTicks?: PositionTickInfo,
-|};
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Runtime#type-CallFrame
-type CallFrame = {|
-  functionName: string,
-  scriptId: string,
-  url: string,
-  lineNumber: string,
-  columnNumber: string,
-|};
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-PositionTickInfo
-type PositionTickInfo = {|
-  line: number,
-  ticks: number,
-|};
-
-export default class Profiler {
-  session: Session;
-
-  startProfiling(): Promise<mixed> {
-    let inspector;
-    try {
-      inspector = require('inspector');
-    } catch (err) {
-      throw new ThrowableDiagnostic({
-        diagnostic: {
-          message: `The inspector module isn't available`,
-          origin: '@parcel/workers',
-          hints: ['Disable build profiling'],
-        },
-      });
-    }
-
-    this.session = new inspector.Session();
-    this.session.connect();
-
-    return Promise.all([
-      this.sendCommand('Profiler.setSamplingInterval', {
-        interval: 100,
-      }),
-      this.sendCommand('Profiler.enable'),
-      this.sendCommand('Profiler.start'),
-    ]);
-  }
-
-  sendCommand(method: string, params: mixed): Promise<{profile: Profile, ...}> {
-    invariant(this.session != null);
-    return new Promise((resolve, reject) => {
-      this.session.post(method, params, (err, params) => {
-        if (err == null) {
-          resolve(params);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-
-  destroy() {
-    if (this.session != null) {
-      this.session.disconnect();
-    }
-  }
-
-  async stopProfiling(): Promise<Profile> {
-    let res = await this.sendCommand('Profiler.stop');
-    this.destroy();
-    return res.profile;
-  }
-}

package/src/Trace.js

@@ -1,125 +0,0 @@
-// @flow
-import type {Profile} from './Profiler';
-import type {Writable} from 'stream';
-import {Tracer} from 'chrome-trace-event';
-
-export default class Trace {
-  tracer: Tracer;
-  tid: number;
-  eventId: number;
-
-  constructor() {
-    this.tracer = new Tracer();
-    this.tid = 0;
-    this.eventId = 0;
-  }
-
-  getEventId(): number {
-    return this.eventId++;
-  }
-
-  init(ts: number) {
-    this.tracer.instantEvent({
-      name: 'TracingStartedInPage',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1',
-          page: '0xfff',
-          frames: [
-            {
-              frame: '0xfff',
-              url: 'parcel',
-              name: '',
-            },
-          ],
-        },
-      },
-    });
-
-    this.tracer.instantEvent({
-      name: 'TracingStartedInBrowser',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1',
-        },
-      },
-    });
-  }
-
-  addCPUProfile(name: string, profile: Profile) {
-    if (this.eventId === 0) {
-      this.init(profile.startTime);
-    }
-    const trace = this.tracer;
-    const tid = this.tid;
-    this.tid++;
-
-    const cpuStartTime = profile.startTime;
-    const cpuEndTime = profile.endTime;
-
-    trace.instantEvent({
-      tid,
-      id: this.getEventId(),
-      cat: ['toplevel'],
-      name: 'TaskQueueManager::ProcessTaskFromWorkQueue',
-      args: {
-        src_file: '../../ipc/ipc_moji_bootstrap.cc',
-        src_func: 'Accept',
-      },
-      ts: cpuStartTime,
-    });
-
-    trace.completeEvent({
-      tid,
-      name: 'EvaluateScript',
-      id: this.getEventId(),
-      cat: ['devtools.timeline'],
-      ts: cpuStartTime,
-      dur: cpuEndTime - cpuStartTime,
-      args: {
-        data: {
-          url: 'parcel',
-          lineNumber: 1,
-          columnNumber: 1,
-          frame: '0xFFF',
-        },
-      },
-    });
-
-    trace.instantEvent({
-      tid,
-      ts: 0,
-      ph: 'M',
-      cat: ['__metadata'],
-      name: 'thread_name',
-      args: {name},
-    });
-
-    trace.instantEvent({
-      tid,
-      name: 'CpuProfile',
-      id: this.getEventId(),
-      cat: ['disabled-by-default-devtools.timeline'],
-      ts: cpuEndTime,
-      args: {
-        data: {
-          cpuProfile: profile,
-        },
-      },
-    });
-  }
-
-  pipe(writable: Writable): stream$Writable {
-    return this.tracer.pipe(writable);
-  }
-
-  flush() {
-    this.tracer.push(null);
-  }
-}