@atlaspack/workers 2.14.21 → 2.14.22-typescript-17c3d1dec.0

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

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

@@ -1,8 +1,11 @@
-// @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 {
-  // $FlowFixMe
+  // @ts-expect-error TS2339
   if (process.browser) return 'web';
 
   switch (process.env.ATLASPACK_WORKER_BACKEND) {
@@ -14,7 +17,7 @@ export function detectBackend(): BackendType {
   try {
     require('worker_threads');
     return 'threads';
-  } catch (err) {
+  } catch (err: any) {
     return 'process';
   }
 }

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

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