@atlaspack/workers 2.14.21-typescript-bc4459c37.0 → 2.14.21

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

@@ -1,21 +1,24 @@
+// @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 | null | undefined;
-  id?: number;
-};
+type HandleOpts = {|
+  fn?: HandleFunction,
+  childId?: ?number,
+  id?: number,
+|};
 
 const handleById: Map<number, Handle> = new Map();
 
 export default class Handle {
   id: number;
-  childId: number | null | undefined;
-  fn: HandleFunction | null | undefined;
+  childId: ?number;
+  fn: ?HandleFunction;
 
   constructor(opts: HandleOpts) {
     this.id = opts.id ?? ++HANDLE_ID;
@@ -28,10 +31,7 @@ export default class Handle {
     handleById.delete(this.id);
   }
 
-  serialize(): {
-    childId: number | null | undefined;
-    id: number;
-  } {
+  serialize(): {|childId: ?number, id: number|} {
     return {
       id: this.id,
       childId: this.childId,

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

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