@atlaspack/workers 2.14.21 → 2.14.22-typescript-5ad950d33.0

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