@atlaspack/workers 2.14.20 → 2.14.21-typescript-80839fbd5.0

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.20",
+  "version": "2.14.21-typescript-80839fbd5.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -11,23 +11,27 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
-  "source": "src/index.js",
-  "types": "index.d.ts",
+  "source": "src/index.ts",
+  "types": "src/index.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3",
-    "@atlaspack/diagnostic": "2.14.1",
-    "@atlaspack/logger": "2.14.13",
-    "@atlaspack/profiler": "2.14.17",
-    "@atlaspack/types-internal": "2.15.2",
-    "@atlaspack/utils": "2.17.2",
+    "@atlaspack/build-cache": "2.13.4-typescript-80839fbd5.0",
+    "@atlaspack/diagnostic": "2.14.2-typescript-80839fbd5.0",
+    "@atlaspack/logger": "2.14.14-typescript-80839fbd5.0",
+    "@atlaspack/profiler": "2.14.18-typescript-80839fbd5.0",
+    "@atlaspack/types-internal": "2.15.3-typescript-80839fbd5.0",
+    "@atlaspack/utils": "2.17.3-typescript-80839fbd5.0",
     "nullthrows": "^1.1.1"
   },
   "browser": {
     "./src/process/ProcessWorker.js": false,
     "./src/threads/ThreadsWorker.js": false
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "scripts": {
+    "check-ts": "tsc --noEmit"
+  },
+  "gitHead": "80839fbd5c6d6668c2622849856a4b25601354a8"
 }

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));
     }
   }