@atlaspack/workers 2.14.21-typescript-e99c742e9.0 → 2.14.21-typescript-5b4d3ad41.0

package/lib/threads/ThreadsChild.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _worker_threads() {
+  const data = require("worker_threads");
+  _worker_threads = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+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) {
+      throw new Error('Only create ThreadsChild instances in a worker!');
+    }
+    this.onMessage = onMessage;
+    this.onExit = onExit;
+    _worker_threads().parentPort.on('message', data => this.handleMessage(data));
+    _worker_threads().parentPort.on('close', this.onExit);
+  }
+  handleMessage(data) {
+    this.onMessage((0, _buildCache().restoreDeserializedObject)(data));
+  }
+  send(data) {
+    (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.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerImpl, MessageHandler, ErrorHandler, ExitHandler, WorkerMessage } from '../types';
+import { Worker } from 'worker_threads';
+export declare let WORKER_PATH: string;
+export default class ThreadsWorker implements WorkerImpl {
+    execArgv: any;
+    onMessage: MessageHandler;
+    onError: ErrorHandler;
+    onExit: ExitHandler;
+    worker: Worker;
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleMessage(data: WorkerMessage): void;
+    send(data: WorkerMessage): void;
+}

package/lib/threads/ThreadsWorker.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.WORKER_PATH = void 0;
+function _worker_threads() {
+  const data = require("worker_threads");
+  _worker_threads = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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;
+    this.onError = onError;
+    this.onExit = onExit;
+  }
+  start() {
+    this.worker = new (_worker_threads().Worker)(WORKER_PATH, {
+      execArgv: this.execArgv,
+      env: process.env
+    });
+    this.worker.on('message', data => this.handleMessage(data));
+    this.worker.on('error', this.onError);
+    this.worker.on('exit', this.onExit);
+    return new Promise(resolve => {
+      this.worker.on('online', resolve);
+    });
+  }
+  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) {
+    this.onMessage((0, _buildCache().restoreDeserializedObject)(data));
+  }
+  send(data) {
+    this.worker.postMessage((0, _buildCache().prepareForSerialization)(data));
+  }
+}
+exports.default = ThreadsWorker;

package/lib/types.d.ts

@@ -0,0 +1,52 @@
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import type { FilePath } from '@atlaspack/types-internal';
+export type LocationCallRequest = {
+    args: ReadonlyArray<unknown>;
+    location: string;
+    method?: string;
+};
+export type HandleCallRequest = {
+    args: ReadonlyArray<unknown>;
+    handle: number;
+};
+export type CallRequest = LocationCallRequest | HandleCallRequest;
+export type WorkerRequest = {
+    args: ReadonlyArray<any>;
+    awaitResponse?: boolean;
+    child?: number | null | undefined;
+    idx?: number;
+    location?: FilePath;
+    method?: string | null | undefined;
+    type: 'request';
+    handle?: number;
+};
+export type WorkerDataResponse = {
+    idx?: number;
+    child?: number;
+    type: 'response';
+    contentType: 'data';
+    content: string;
+};
+export type WorkerErrorResponse = {
+    idx?: number;
+    child?: number;
+    type: 'response';
+    contentType: 'error';
+    content: Diagnostic | Array<Diagnostic>;
+};
+export type WorkerResponse = WorkerDataResponse | WorkerErrorResponse;
+export type WorkerMessage = WorkerRequest | WorkerResponse;
+export type MessageHandler = (data: WorkerMessage) => void;
+export type ErrorHandler = (err: Error) => void;
+export type ExitHandler = (code: number) => void;
+export interface WorkerImpl {
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(data: WorkerMessage): void;
+}
+export interface ChildImpl {
+    constructor(onMessage: MessageHandler, onExit: ExitHandler): void;
+    send(data: WorkerMessage): void;
+}
+export type BackendType = 'threads' | 'process' | 'web';

package/lib/types.js

@@ -0,0 +1 @@
+"use strict";

package/lib/web/WebChild.d.ts

@@ -0,0 +1,8 @@
+import type { ChildImpl, MessageHandler, ExitHandler, WorkerMessage } from '../types';
+export default class WebChild implements ChildImpl {
+    onMessage: MessageHandler;
+    onExit: ExitHandler;
+    constructor(onMessage: MessageHandler, onExit: ExitHandler);
+    handleMessage(data: WorkerMessage): void;
+    send(data: WorkerMessage): void;
+}

package/lib/web/WebChild.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+var _child = require("../child");
+var _childState = require("../childState");
+/* eslint-env worker*/
+
+// Type declarations for Web Worker environment
+
+// @ts-expect-error TS2420
+class WebChild {
+  constructor(onMessage, onExit) {
+    if (!(typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)) {
+      throw new Error('Only create WebChild instances in a worker!');
+    }
+    this.onMessage = onMessage;
+    this.onExit = onExit;
+    self.addEventListener('message', ({
+      data
+    }) => {
+      if (data === 'stop') {
+        this.onExit(0);
+        self.postMessage('stopped');
+      }
+      this.handleMessage(data);
+    });
+    self.postMessage('online');
+  }
+  handleMessage(data) {
+    this.onMessage((0, _buildCache().restoreDeserializedObject)(data));
+  }
+  send(data) {
+    self.postMessage((0, _buildCache().prepareForSerialization)(data));
+  }
+}
+
+// @ts-expect-error TS2345
+exports.default = WebChild;
+(0, _childState.setChild)(new _child.Child(WebChild));

package/lib/web/WebWorker.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerImpl, MessageHandler, ErrorHandler, ExitHandler, WorkerMessage } from '../types';
+export declare let WORKER_PATH: import("url").URL;
+export default class WebWorker implements WorkerImpl {
+    execArgv: any;
+    onMessage: MessageHandler;
+    onError: ErrorHandler;
+    onExit: ExitHandler;
+    worker: Worker;
+    stopping: Promise<undefined> | null | undefined;
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleMessage(data: WorkerMessage): void;
+    send(data: WorkerMessage): void;
+}

package/lib/web/WebWorker.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.WORKER_PATH = void 0;
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+let id = 0;
+
+// @ts-expect-error This is actually a module
+let WORKER_PATH = 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 = WORKER_PATH = new URL('./WebChild.ts', import.meta.url);
+}
+
+// @ts-expect-error TS2420
+class WebWorker {
+  // @ts-expect-error TS2564
+
+  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().makeDeferredWithPromise)();
+
+    // @ts-expect-error TS7031
+    this.worker.onmessage = ({
+      data
+    }) => {
+      if (data === 'online') {
+        // @ts-expect-error TS2554
+        deferred.resolve();
+        return;
+      }
+      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);
+
+    // @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().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, _buildCache().restoreDeserializedObject)(data));
+  }
+  send(data) {
+    this.worker.postMessage((0, _buildCache().prepareForSerialization)(data));
+  }
+}
+exports.default = WebWorker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/workers",
-  "version": "2.14.21-typescript-e99c742e9.0",
+  "version": "2.14.21-typescript-5b4d3ad41.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -17,12 +17,12 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.4-typescript-e99c742e9.0",
-    "@atlaspack/diagnostic": "2.14.2-typescript-e99c742e9.0",
-    "@atlaspack/logger": "2.14.14-typescript-e99c742e9.0",
-    "@atlaspack/profiler": "2.14.18-typescript-e99c742e9.0",
-    "@atlaspack/types-internal": "2.15.3-typescript-e99c742e9.0",
-    "@atlaspack/utils": "2.17.3-typescript-e99c742e9.0",
+    "@atlaspack/build-cache": "2.13.4-typescript-5b4d3ad41.0",
+    "@atlaspack/diagnostic": "2.14.2-typescript-5b4d3ad41.0",
+    "@atlaspack/logger": "2.14.14-typescript-5b4d3ad41.0",
+    "@atlaspack/profiler": "2.14.18-typescript-5b4d3ad41.0",
+    "@atlaspack/types-internal": "2.15.3-typescript-5b4d3ad41.0",
+    "@atlaspack/utils": "2.17.3-typescript-5b4d3ad41.0",
     "nullthrows": "^1.1.1"
   },
   "browser": {
@@ -33,5 +33,5 @@
   "scripts": {
     "check-ts": "tsc --emitDeclarationOnly --rootDir src"
   },
-  "gitHead": "e99c742e92175ac411d807daf2ba45d5bacebb58"
+  "gitHead": "5b4d3ad41ffa002b989ba77271bb3010a1f05b2a"
 }