@atlaspack/workers 2.14.5-canary.138 → 2.14.5-canary.139

package/lib/process/ProcessWorker.d.ts

@@ -0,0 +1,16 @@
+import type { WorkerImpl, MessageHandler, ErrorHandler, ExitHandler, WorkerMessage } from '../types';
+import { ChildProcess } from 'child_process';
+export declare let WORKER_PATH: string;
+export default class ProcessWorker implements WorkerImpl {
+    execArgv: any;
+    onMessage: MessageHandler;
+    onError: ErrorHandler;
+    onExit: ExitHandler;
+    child: ChildProcess;
+    processQueue: boolean;
+    sendQueue: Array<any>;
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(data: WorkerMessage): void;
+}

package/lib/process/ProcessWorker.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _child_process() {
   const data = _interopRequireDefault(require("child_process"));
   _child_process = function () {
@@ -26,8 +26,15 @@ function _buildCache() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, './ProcessChild.js');
+let WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'ProcessChild.js');
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  exports.WORKER_PATH = WORKER_PATH = _path().default.join(__dirname, 'ProcessChild.ts');
+}
+
+// @ts-expect-error TS2420
 class ProcessWorker {
+  // @ts-expect-error TS2564
+
   processQueue = true;
   sendQueue = [];
   constructor(execArgv, onMessage, onError, onExit) {

package/lib/threads/ThreadsChild.d.ts

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

package/lib/threads/ThreadsChild.js

@@ -28,6 +28,7 @@ function _nullthrows() {
 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) {
@@ -45,5 +46,7 @@ class ThreadsChild {
     (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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _worker_threads() {
   const data = require("worker_threads");
   _worker_threads = function () {
@@ -26,8 +26,15 @@ function _buildCache() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, './ThreadsChild.js');
+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;
@@ -49,6 +56,7 @@ class ThreadsWorker {
   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) {

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/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

@@ -14,6 +14,10 @@ function _buildCache() {
 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)) {
@@ -28,7 +32,6 @@ class WebChild {
         this.onExit(0);
         self.postMessage('stopped');
       }
-      // $FlowFixMe assume WorkerMessage as data
       this.handleMessage(data);
     });
     self.postMessage('online');
@@ -40,5 +43,7 @@ class WebChild {
     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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _buildCache() {
   const data = require("@atlaspack/build-cache");
   _buildCache = function () {
@@ -19,7 +19,18 @@ function _utils() {
   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;
@@ -27,7 +38,7 @@ class WebWorker {
     this.onExit = onExit;
   }
   start() {
-    // $FlowFixMe[incompatible-call]
+    // @ts-expect-error TS1470
     this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
       name: `Parcel Worker ${id++}`,
       type: 'module'
@@ -36,25 +47,28 @@ class WebWorker {
       deferred,
       promise
     } = (0, _utils().makeDeferredWithPromise)();
+
+    // @ts-expect-error TS7031
     this.worker.onmessage = ({
       data
     }) => {
       if (data === 'online') {
+        // @ts-expect-error TS2554
         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);
 
+    // @ts-expect-error TS2322
     return promise;
   }
   stop() {
     if (!this.stopping) {
+      // @ts-expect-error TS2322
       this.stopping = (async () => {
         this.worker.postMessage('stop');
         let {
@@ -65,6 +79,7 @@ class WebWorker {
           data
         }) => {
           if (data === 'stopped') {
+            // @ts-expect-error TS2554
             deferred.resolve();
           }
         });
@@ -73,6 +88,7 @@ class WebWorker {
         this.onExit(0);
       })();
     }
+    // @ts-expect-error TS2322
     return this.stopping;
   }
   handleMessage(data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/workers",
-  "version": "2.14.5-canary.138+eda07caaf",
+  "version": "2.14.5-canary.139+d2fd84977",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,19 +10,19 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
-  "types": "index.d.ts",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.206+eda07caaf",
-    "@atlaspack/diagnostic": "2.14.1-canary.206+eda07caaf",
-    "@atlaspack/logger": "2.14.5-canary.138+eda07caaf",
-    "@atlaspack/profiler": "2.14.1-canary.206+eda07caaf",
-    "@atlaspack/types-internal": "2.14.1-canary.206+eda07caaf",
-    "@atlaspack/utils": "2.14.5-canary.138+eda07caaf",
+    "@atlaspack/build-cache": "2.13.3-canary.207+d2fd84977",
+    "@atlaspack/diagnostic": "2.14.1-canary.207+d2fd84977",
+    "@atlaspack/logger": "2.14.5-canary.139+d2fd84977",
+    "@atlaspack/profiler": "2.14.1-canary.207+d2fd84977",
+    "@atlaspack/types-internal": "2.14.1-canary.207+d2fd84977",
+    "@atlaspack/utils": "2.14.5-canary.139+d2fd84977",
     "nullthrows": "^1.1.1"
   },
   "browser": {
@@ -30,5 +30,8 @@
     "./src/threads/ThreadsWorker.js": false
   },
   "type": "commonjs",
-  "gitHead": "eda07caafd2ebb814bbdbfd0ec12fa63124e213f"
-}
+  "scripts": {
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
+  },
+  "gitHead": "d2fd849770fe6305e9c694bd97b1bd905abd9d94"
+}

package/src/{Handle.js → Handle.ts}

@@ -1,24 +1,21 @@
-// @flow strict-local
 import {registerSerializableClass} from '@atlaspack/build-cache';
-// $FlowFixMe
 import packageJson from '../package.json';
 
 let HANDLE_ID = 0;
-// $FlowFixMe
 export type HandleFunction = (...args: Array<any>) => any;
 
-type HandleOpts = {|
-  fn?: HandleFunction,
-  childId?: ?number,
-  id?: number,
-|};
+type HandleOpts = {
+  fn?: HandleFunction;
+  childId?: number | null | undefined;
+  id?: number;
+};
 
 const handleById: Map<number, Handle> = new Map();
 
 export default class Handle {
   id: number;
-  childId: ?number;
-  fn: ?HandleFunction;
+  childId: number | null | undefined;
+  fn: HandleFunction | null | undefined;
 
   constructor(opts: HandleOpts) {
     this.id = opts.id ?? ++HANDLE_ID;
@@ -31,7 +28,10 @@ export default class Handle {
     handleById.delete(this.id);
   }
 
-  serialize(): {|childId: ?number, id: number|} {
+  serialize(): {
+    childId: number | null | undefined;
+    id: number;
+  } {
     return {
       id: this.id,
       childId: this.childId,

package/src/{Worker.js → Worker.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import type {FilePath} from '@atlaspack/types-internal';
 import type {BackendType, WorkerImpl, WorkerMessage} from './types';
 import type {SharedReference} from './WorkerFarm';
@@ -9,33 +7,34 @@ import EventEmitter from 'events';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import {getWorkerBackend} from './backend';
 
-export type WorkerCall = {|
-  method?: string,
-  handle?: number,
-  args: $ReadOnlyArray<any>,
-  retries: number,
-  skipReadyCheck?: boolean,
-  resolve: (result: Promise<any> | any) => void,
-  reject: (error: any) => void,
-|};
-
-type WorkerOpts = {|
-  forcedKillTime: number,
-  backend: BackendType,
-  shouldPatchConsole?: boolean,
-  shouldTrace?: boolean,
-  sharedReferences: $ReadOnlyMap<SharedReference, mixed>,
-|};
+export type WorkerCall = {
+  method?: string;
+  handle?: number;
+  args: ReadonlyArray<any>;
+  retries: number;
+  skipReadyCheck?: boolean;
+  resolve: (result: Promise<any> | any) => void;
+  reject: (error?: any) => void;
+};
+
+type WorkerOpts = {
+  forcedKillTime: number;
+  backend: BackendType;
+  shouldPatchConsole?: boolean;
+  shouldTrace?: boolean;
+  sharedReferences: ReadonlyMap<SharedReference, unknown>;
+};
 
 let WORKER_ID = 0;
 export default class Worker extends EventEmitter {
-  +options: WorkerOpts;
+  readonly options: WorkerOpts;
+  // @ts-expect-error TS2564
   worker: WorkerImpl;
   id: number = WORKER_ID++;
   sentSharedReferences: Set<SharedReference> = new Set();
 
   calls: Map<number, WorkerCall> = new Map();
-  exitCode: ?number = null;
+  exitCode: number | null | undefined = null;
   callId: number = 0;
 
   ready: boolean = false;
@@ -48,7 +47,7 @@ export default class Worker extends EventEmitter {
   }
 
   async fork(forkModule: FilePath) {
-    let filteredArgs = [];
+    let filteredArgs: Array<string> | Array<any | string> = [];
     if (process.execArgv) {
       filteredArgs = process.execArgv.filter(
         (v) =>
@@ -94,13 +93,13 @@ export default class Worker extends EventEmitter {
       }
     }
 
-    let onMessage = (data) => this.receive(data);
-    let onExit = (code) => {
+    let onMessage = (data: WorkerMessage) => this.receive(data);
+    let onExit = (code: number) => {
       this.exitCode = code;
       this.emit('exit', code);
     };
 
-    let onError = (err) => {
+    let onError = (err: Error) => {
       this.emit('error', err);
     };
 
@@ -108,22 +107,27 @@ export default class Worker extends EventEmitter {
     this.worker = new WorkerBackend(filteredArgs, onMessage, onError, onExit);
     await this.worker.start();
 
-    await new Promise((resolve, reject) => {
-      this.call({
-        method: 'childInit',
-        args: [
-          forkModule,
-          {
-            shouldPatchConsole: !!this.options.shouldPatchConsole,
-            shouldTrace: !!this.options.shouldTrace,
-          },
-        ],
-        retries: 0,
-        skipReadyCheck: true,
-        resolve,
-        reject,
-      });
-    });
+    await new Promise(
+      (
+        resolve: (result: Promise<any> | any) => void,
+        reject: (error?: any) => void,
+      ) => {
+        this.call({
+          method: 'childInit',
+          args: [
+            forkModule,
+            {
+              shouldPatchConsole: !!this.options.shouldPatchConsole,
+              shouldTrace: !!this.options.shouldTrace,
+            },
+          ],
+          retries: 0,
+          skipReadyCheck: true,
+          resolve,
+          reject,
+        });
+      },
+    );
 
     let sharedRefs = this.options.sharedReferences;
     let refsShared = new Set();
@@ -131,8 +135,9 @@ export default class Worker extends EventEmitter {
     while (refsShared.size < sharedRefs.size) {
       await Promise.all(
         [...sharedRefs]
-          .filter(([ref]) => !refsShared.has(ref))
-          .map(async ([ref, value]) => {
+          // @ts-expect-error TS2769
+          .filter(([ref]: [any]) => !refsShared.has(ref))
+          .map(async ([ref, value]: [any, any]) => {
             await this.sendSharedReference(ref, value);
             refsShared.add(ref);
           }),
@@ -143,18 +148,23 @@ export default class Worker extends EventEmitter {
     this.emit('ready');
   }
 
-  sendSharedReference(ref: SharedReference, value: mixed): Promise<any> {
+  sendSharedReference(ref: SharedReference, value: unknown): Promise<any> {
     this.sentSharedReferences.add(ref);
-    return new Promise((resolve, reject) => {
-      this.call({
-        method: 'createSharedReference',
-        args: [ref, value],
-        resolve,
-        reject,
-        retries: 0,
-        skipReadyCheck: true,
-      });
-    });
+    return new Promise(
+      (
+        resolve: (result: Promise<any> | any) => void,
+        reject: (error?: any) => void,
+      ) => {
+        this.call({
+          method: 'createSharedReference',
+          args: [ref, value],
+          resolve,
+          reject,
+          retries: 0,
+          skipReadyCheck: true,
+        });
+      },
+    );
   }
 
   send(data: WorkerMessage): void {
@@ -179,8 +189,10 @@ export default class Worker extends EventEmitter {
     };
 
     if (this.ready || call.skipReadyCheck === true) {
+      // @ts-expect-error TS2345
       this.send(msg);
     } else {
+      // @ts-expect-error TS2345
       this.once('ready', () => this.send(msg));
     }
   }