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

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

@@ -1,3 +1,5 @@
+// @flow
+
 import type {ErrorWithCode, FilePath} from '@atlaspack/types-internal';
 import type {
   CallRequest,
@@ -20,7 +22,7 @@ import {
   serialize,
 } from '@atlaspack/build-cache';
 import ThrowableDiagnostic, {anyToDiagnostic, md} from '@atlaspack/diagnostic';
-import Worker, {WorkerCall} from './Worker';
+import Worker, {type WorkerCall} from './Worker';
 import cpuCount from './cpuCount';
 import Handle from './Handle';
 import {child} from './childState';
@@ -31,34 +33,32 @@ import logger from '@atlaspack/logger';
 
 let referenceId = 1;
 
-export type SharedReference = number;
-
-export type FarmOptions = {
-  maxConcurrentWorkers: number;
-  maxConcurrentCallsPerWorker: number;
-  forcedKillTime: number;
-  useLocalWorker: boolean;
-  warmWorkers: boolean;
-  workerPath?: FilePath;
-  backend: BackendType;
-  shouldPatchConsole?: boolean;
-  shouldTrace?: boolean;
-};
+export opaque type SharedReference = number;
+
+export type FarmOptions = {|
+  maxConcurrentWorkers: number,
+  maxConcurrentCallsPerWorker: number,
+  forcedKillTime: number,
+  useLocalWorker: boolean,
+  warmWorkers: boolean,
+  workerPath?: FilePath,
+  backend: BackendType,
+  shouldPatchConsole?: boolean,
+  shouldTrace?: boolean,
+|};
 
 type WorkerModule = {
-  readonly [key: string]: (...args: Array<unknown>) => Promise<unknown>;
+  +[string]: (...args: Array<mixed>) => Promise<mixed>,
+  ...
 };
 
-export type WorkerApi = {
-  callMaster(
-    arg1: CallRequest,
-    arg2?: boolean | null | undefined,
-  ): Promise<unknown>;
-  createReverseHandle(fn: HandleFunction): Handle;
-  getSharedReference(ref: SharedReference): unknown;
-  resolveSharedReference(value: unknown): SharedReference | null | undefined;
-  callChild?: (childId: number, request: HandleCallRequest) => Promise<unknown>;
-};
+export type WorkerApi = {|
+  callMaster(CallRequest, ?boolean): Promise<mixed>,
+  createReverseHandle(fn: HandleFunction): Handle,
+  getSharedReference(ref: SharedReference): mixed,
+  resolveSharedReference(value: mixed): ?SharedReference,
+  callChild?: (childId: number, request: HandleCallRequest) => Promise<mixed>,
+|};
 
 export {Handle};
 
@@ -72,22 +72,19 @@ export default class WorkerFarm extends EventEmitter {
   callQueue: Array<WorkerCall> = [];
   ending: boolean = false;
   localWorker: WorkerModule;
-  localWorkerInit: Promise<undefined> | null | undefined;
+  localWorkerInit: ?Promise<void>;
   options: FarmOptions;
   run: HandleFunction;
   warmWorkers: number = 0;
   readyWorkers: number = 0;
   workers: Map<number, Worker> = new Map();
   handles: Map<number, Handle> = new Map();
-  sharedReferences: Map<SharedReference, unknown> = new Map();
-  sharedReferencesByValue: Map<unknown, SharedReference> = new Map();
-  serializedSharedReferences: Map<
-    SharedReference,
-    ArrayBuffer | null | undefined
-  > = new Map();
-  profiler: SamplingProfiler | null | undefined;
-
-  constructor(farmOptions: Partial<FarmOptions> = {}) {
+  sharedReferences: Map<SharedReference, mixed> = new Map();
+  sharedReferencesByValue: Map<mixed, SharedReference> = new Map();
+  serializedSharedReferences: Map<SharedReference, ?ArrayBuffer> = new Map();
+  profiler: ?SamplingProfiler;
+
+  constructor(farmOptions: $Shape<FarmOptions> = {}) {
     super();
     this.options = {
       maxConcurrentWorkers: WorkerFarm.getNumWorkers(),
@@ -105,9 +102,9 @@ export default class WorkerFarm extends EventEmitter {
       throw new Error('Please provide a worker path!');
     }
 
+    // $FlowFixMe
     this.localWorker = require(this.options.workerPath);
 
-    // @ts-expect-error TS2322
     this.localWorkerInit =
       this.localWorker.childInit != null ? this.localWorker.childInit() : null;
 
@@ -131,58 +128,47 @@ export default class WorkerFarm extends EventEmitter {
     this.startMaxWorkers();
   }
 
-  workerApi: {
-    callChild: (
-      childId: number,
-      request: HandleCallRequest,
-    ) => Promise<unknown>;
+  workerApi: {|
+    callChild: (childId: number, request: HandleCallRequest) => Promise<mixed>,
     callMaster: (
       request: CallRequest,
-      awaitResponse?: boolean | null | undefined,
-    ) => Promise<unknown>;
-    createReverseHandle: (fn: HandleFunction) => Handle;
-    getSharedReference: (ref: SharedReference) => unknown;
-    resolveSharedReference: (value: unknown) => undefined | SharedReference;
-    runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
-  } = {
+      awaitResponse?: ?boolean,
+    ) => Promise<mixed>,
+    createReverseHandle: (fn: HandleFunction) => Handle,
+    getSharedReference: (ref: SharedReference) => mixed,
+    resolveSharedReference: (value: mixed) => void | SharedReference,
+    runHandle: (handle: Handle, args: Array<any>) => Promise<mixed>,
+  |} = {
     callMaster: async (
       request: CallRequest,
-      awaitResponse: boolean | null = true,
-    ): Promise<unknown> => {
+      awaitResponse: ?boolean = true,
+    ): Promise<mixed> => {
+      // $FlowFixMe
       let result = await this.processRequest({
         ...request,
-        // @ts-expect-error TS2322
         awaitResponse,
       });
       return deserialize(serialize(result));
     },
     createReverseHandle: (fn: HandleFunction): Handle =>
       this.createReverseHandle(fn),
-    callChild: (
-      childId: number,
-      request: HandleCallRequest,
-    ): Promise<unknown> =>
-      new Promise(
-        (
-          resolve: (result: Promise<any> | any) => void,
-          reject: (error?: any) => void,
-        ) => {
-          nullthrows(this.workers.get(childId)).call({
-            ...request,
-            resolve,
-            reject,
-            retries: 0,
-          });
-        },
-      ),
-    runHandle: (handle: Handle, args: Array<any>): Promise<unknown> =>
+    callChild: (childId: number, request: HandleCallRequest): Promise<mixed> =>
+      new Promise((resolve, reject) => {
+        nullthrows(this.workers.get(childId)).call({
+          ...request,
+          resolve,
+          reject,
+          retries: 0,
+        });
+      }),
+    runHandle: (handle: Handle, args: Array<any>): Promise<mixed> =>
       this.workerApi.callChild(nullthrows(handle.childId), {
         handle: handle.id,
         args,
       }),
     getSharedReference: (ref: SharedReference) =>
       this.sharedReferences.get(ref),
-    resolveSharedReference: (value: unknown) =>
+    resolveSharedReference: (value: mixed) =>
       this.sharedReferencesByValue.get(value),
   };
 
@@ -248,13 +234,9 @@ export default class WorkerFarm extends EventEmitter {
     };
   }
 
-  onError(
-    error: ErrorWithCode,
-    worker: Worker,
-  ): undefined | Promise<undefined> {
+  onError(error: ErrorWithCode, worker: Worker): void | Promise<void> {
     // Handle ipc errors
     if (error.code === 'ERR_IPC_CHANNEL_CLOSED') {
-      // @ts-expect-error TS2322
       return this.stopWorker(worker);
     } else {
       logger.error(error, '@atlaspack/workers');
@@ -332,7 +314,6 @@ export default class WorkerFarm extends EventEmitter {
       }
 
       if (worker.calls.size < this.options.maxConcurrentCallsPerWorker) {
-        // @ts-expect-error TS2345
         this.callWorker(worker, this.callQueue.shift());
       }
     }
@@ -352,24 +333,25 @@ export default class WorkerFarm extends EventEmitter {
   }
 
   async processRequest(
-    data: {
-      location: FilePath;
-    } & Partial<WorkerRequest>,
+    data: {|
+      location: FilePath,
+    |} & $Shape<WorkerRequest>,
     worker?: Worker,
-  ): Promise<string | null | undefined> {
+  ): Promise<?string> {
     let {method, args, location, awaitResponse, idx, handle: handleId} = data;
     let mod;
     if (handleId != null) {
       mod = nullthrows(this.handles.get(handleId)?.fn);
     } else if (location) {
-      // @ts-expect-error TS2339
+      // $FlowFixMe
       if (process.browser) {
         if (location === '@atlaspack/workers/bus') {
-          mod = bus as any;
+          mod = (bus: any);
         } else {
           throw new Error('No dynamic require possible: ' + location);
         }
       } else {
+        // $FlowFixMe this must be dynamic
         mod = require(location);
       }
     } else {
@@ -393,9 +375,8 @@ export default class WorkerFarm extends EventEmitter {
     let result;
     if (method == null) {
       try {
-        // @ts-expect-error TS2488
         result = responseFromContent(await mod(...args));
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     } else {
@@ -405,8 +386,9 @@ export default class WorkerFarm extends EventEmitter {
       }
 
       try {
+        // $FlowFixMe
         result = responseFromContent(await mod[method](...args));
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     }
@@ -428,21 +410,16 @@ export default class WorkerFarm extends EventEmitter {
       throw new Error('Cannot add a worker call if workerfarm is ending.');
     }
 
-    return new Promise(
-      (
-        resolve: (result: Promise<any> | any) => void,
-        reject: (error?: any) => void,
-      ) => {
-        this.callQueue.push({
-          method,
-          args: args,
-          retries: 0,
-          resolve,
-          reject,
-        });
-        this.processQueue();
-      },
-    );
+    return new Promise((resolve, reject) => {
+      this.callQueue.push({
+        method,
+        args: args,
+        retries: 0,
+        resolve,
+        reject,
+      });
+      this.processQueue();
+    });
   }
 
   async end(): Promise<void> {
@@ -489,12 +466,9 @@ export default class WorkerFarm extends EventEmitter {
   }
 
   createSharedReference(
-    value: unknown,
+    value: mixed,
     isCacheable: boolean = true,
-  ): {
-    ref: SharedReference;
-    dispose(): Promise<unknown>;
-  } {
+  ): {|ref: SharedReference, dispose(): Promise<mixed>|} {
     let ref = referenceId++;
     this.sharedReferences.set(ref, value);
     this.sharedReferencesByValue.set(value, ref);
@@ -509,7 +483,7 @@ export default class WorkerFarm extends EventEmitter {
         this.sharedReferencesByValue.delete(value);
         this.serializedSharedReferences.delete(ref);
 
-        let promises: Array<Promise<any>> = [];
+        let promises = [];
         for (let worker of this.workers.values()) {
           if (!worker.sentSharedReferences.has(ref)) {
             continue;
@@ -517,21 +491,16 @@ export default class WorkerFarm extends EventEmitter {
 
           worker.sentSharedReferences.delete(ref);
           promises.push(
-            new Promise(
-              (
-                resolve: (result: Promise<any> | any) => void,
-                reject: (error?: any) => void,
-              ) => {
-                worker.call({
-                  method: 'deleteSharedReference',
-                  args: [ref],
-                  resolve,
-                  reject,
-                  skipReadyCheck: true,
-                  retries: 0,
-                });
-              },
-            ),
+            new Promise((resolve, reject) => {
+              worker.call({
+                method: 'deleteSharedReference',
+                args: [ref],
+                resolve,
+                reject,
+                skipReadyCheck: true,
+                retries: 0,
+              });
+            }),
           );
         }
         return Promise.all(promises);
@@ -551,33 +520,26 @@ export default class WorkerFarm extends EventEmitter {
     // If the reference was created with the isCacheable option set to false,
     // serializedSharedReferences will contain `null` as the value.
     if (cached !== null) {
-      // @ts-expect-error TS2345
       this.serializedSharedReferences.set(ref, buf);
     }
 
-    // @ts-expect-error TS2322
     return buf;
   }
 
   async startProfile() {
-    let promises: Array<Promise<unknown> | Promise<any>> = [];
+    let promises = [];
     for (let worker of this.workers.values()) {
       promises.push(
-        new Promise(
-          (
-            resolve: (result: Promise<any> | any) => void,
-            reject: (error?: any) => void,
-          ) => {
-            worker.call({
-              method: 'startProfile',
-              args: [],
-              resolve,
-              reject,
-              retries: 0,
-              skipReadyCheck: true,
-            });
-          },
-        ),
+        new Promise((resolve, reject) => {
+          worker.call({
+            method: 'startProfile',
+            args: [],
+            resolve,
+            reject,
+            retries: 0,
+            skipReadyCheck: true,
+          });
+        }),
       );
     }
 
@@ -598,21 +560,16 @@ export default class WorkerFarm extends EventEmitter {
     for (let worker of this.workers.values()) {
       names.push('Worker ' + worker.id);
       promises.push(
-        new Promise(
-          (
-            resolve: (result: Promise<any> | any) => void,
-            reject: (error?: any) => void,
-          ) => {
-            worker.call({
-              method: 'endProfile',
-              args: [],
-              resolve,
-              reject,
-              retries: 0,
-              skipReadyCheck: true,
-            });
-          },
-        ),
+        new Promise((resolve, reject) => {
+          worker.call({
+            method: 'endProfile',
+            args: [],
+            resolve,
+            reject,
+            retries: 0,
+            skipReadyCheck: true,
+          });
+        }),
       );
     }
 
@@ -622,40 +579,33 @@ export default class WorkerFarm extends EventEmitter {
     let stream = trace.pipe(fs.createWriteStream(filename));
 
     for (let profile of profiles) {
-      // @ts-expect-error TS2345
       trace.addCPUProfile(names.shift(), profile);
     }
 
     trace.flush();
-    await new Promise((resolve: (result: Promise<never>) => void) => {
+    await new Promise((resolve) => {
       stream.once('finish', resolve);
     });
 
     logger.info({
       origin: '@atlaspack/workers',
-      // @ts-expect-error TS2345
       message: md`Wrote profile to ${filename}`,
     });
   }
 
   async callAllWorkers(method: string, args: Array<any>) {
-    let promises: Array<Promise<unknown> | Promise<any>> = [];
+    let promises = [];
     for (let worker of this.workers.values()) {
       promises.push(
-        new Promise(
-          (
-            resolve: (result: Promise<any> | any) => void,
-            reject: (error?: any) => void,
-          ) => {
-            worker.call({
-              method,
-              args,
-              resolve,
-              reject,
-              retries: 0,
-            });
-          },
-        ),
+        new Promise((resolve, reject) => {
+          worker.call({
+            method,
+            args,
+            resolve,
+            reject,
+            retries: 0,
+          });
+        }),
       );
     }
 
@@ -670,27 +620,21 @@ export default class WorkerFarm extends EventEmitter {
       let snapshotPaths = await Promise.all(
         [...this.workers.values()].map(
           (worker) =>
-            new Promise(
-              (
-                resolve: (result: Promise<any> | any) => void,
-                reject: (error?: any) => void,
-              ) => {
-                worker.call({
-                  method: 'takeHeapSnapshot',
-                  args: [snapshotId],
-                  resolve,
-                  reject,
-                  retries: 0,
-                  skipReadyCheck: true,
-                });
-              },
-            ),
+            new Promise((resolve, reject) => {
+              worker.call({
+                method: 'takeHeapSnapshot',
+                args: [snapshotId],
+                resolve,
+                reject,
+                retries: 0,
+                skipReadyCheck: true,
+              });
+            }),
         ),
       );
 
       logger.info({
         origin: '@atlaspack/workers',
-        // @ts-expect-error TS2345
         message: md`Wrote heap snapshots to the following paths:\n${snapshotPaths.join(
           '\n',
         )}`,
@@ -713,16 +657,16 @@ export default class WorkerFarm extends EventEmitter {
     return !!child;
   }
 
-  static getWorkerApi(): {
+  static getWorkerApi(): {|
     callMaster: (
       request: CallRequest,
-      awaitResponse?: boolean | null | undefined,
-    ) => Promise<unknown>;
-    createReverseHandle: (fn: (...args: Array<any>) => unknown) => Handle;
-    getSharedReference: (ref: SharedReference) => unknown;
-    resolveSharedReference: (value: unknown) => undefined | SharedReference;
-    runHandle: (handle: Handle, args: Array<any>) => Promise<unknown>;
-  } {
+      awaitResponse?: ?boolean,
+    ) => Promise<mixed>,
+    createReverseHandle: (fn: (...args: Array<any>) => mixed) => Handle,
+    getSharedReference: (ref: SharedReference) => mixed,
+    resolveSharedReference: (value: mixed) => void | SharedReference,
+    runHandle: (handle: Handle, args: Array<any>) => Promise<mixed>,
+  |} {
     invariant(
       child != null,
       'WorkerFarm.getWorkerApi can only be called within workers',
@@ -731,10 +675,9 @@ export default class WorkerFarm extends EventEmitter {
   }
 
   static getConcurrentCallsPerWorker(
-    defaultValue: number = DEFAULT_MAX_CONCURRENT_CALLS,
+    defaultValue?: number = DEFAULT_MAX_CONCURRENT_CALLS,
   ): number {
     return (
-      // @ts-expect-error TS2345
       parseInt(process.env.ATLASPACK_MAX_CONCURRENT_CALLS, 10) || defaultValue
     );
   }

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

@@ -1,11 +1,8 @@
+// @flow
 import type {BackendType, WorkerImpl} from './types';
 
-// flow-to-ts helpers
-export type Class<T> = new (...args: any[]) => T;
-// /flow-to-ts helpers
-
 export function detectBackend(): BackendType {
-  // @ts-expect-error TS2339
+  // $FlowFixMe
   if (process.browser) return 'web';
 
   switch (process.env.ATLASPACK_WORKER_BACKEND) {
@@ -17,7 +14,7 @@ export function detectBackend(): BackendType {
   try {
     require('worker_threads');
     return 'threads';
-  } catch (err: any) {
+  } catch (err) {
     return 'process';
   }
 }

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

@@ -1,3 +1,4 @@
+// @flow
 import EventEmitter from 'events';
 import {child} from './childState';
 
@@ -6,7 +7,7 @@ class Bus extends EventEmitter {
     if (child) {
       child.workerApi.callMaster(
         {
-          // @ts-expect-error TS2339
+          // $FlowFixMe
           location: process.browser ? '@atlaspack/workers/bus' : __filename,
           method: 'emit',
           args: [event, ...args],
@@ -20,4 +21,4 @@ class Bus extends EventEmitter {
   }
 }
 
-export default new Bus() as Bus;
+export default (new Bus(): Bus);