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

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

@@ -1,3 +1,5 @@
+// @flow
+
 import type {
   CallRequest,
   WorkerDataResponse,
@@ -19,37 +21,32 @@ import bus from './bus';
 import {SamplingProfiler, tracer} from '@atlaspack/profiler';
 import _Handle from './Handle';
 
-// flow-to-ts helpers
-export type Class<T> = new (...args: any[]) => T;
-// /flow-to-ts helpers
-
 // The import of './Handle' should really be imported eagerly (with @babel/plugin-transform-modules-commonjs's lazy mode).
 const Handle = _Handle;
 
-type ChildCall = WorkerRequest & {
-  resolve: (result: Promise<any> | any) => void;
-  reject: (error?: any) => void;
-};
+type ChildCall = WorkerRequest & {|
+  resolve: (result: Promise<any> | any) => void,
+  reject: (error: any) => void,
+|};
 
 export class Child {
   callQueue: Array<ChildCall> = [];
-  childId: number | null | undefined;
+  childId: ?number;
   maxConcurrentCalls: number = 10;
-  module: any | null | undefined;
+  module: ?any;
   responseId: number = 0;
   responseQueue: Map<number, ChildCall> = new Map();
   loggerDisposable: IDisposable;
   tracerDisposable: IDisposable;
   child: ChildImpl;
-  profiler: SamplingProfiler | null | undefined;
-  // @ts-expect-error TS2749
+  profiler: ?SamplingProfiler;
   handles: Map<number, Handle> = new Map();
-  sharedReferences: Map<SharedReference, unknown> = new Map();
-  sharedReferencesByValue: Map<unknown, SharedReference> = new Map();
+  sharedReferences: Map<SharedReference, mixed> = new Map();
+  sharedReferencesByValue: Map<mixed, SharedReference> = new Map();
 
   constructor(ChildBackend: Class<ChildImpl>) {
     this.child = new ChildBackend(
-      (m: WorkerMessage) => {
+      (m) => {
         this.messageListener(m);
       },
       () => this.handleEnd(),
@@ -66,31 +63,27 @@ export class Child {
     });
   }
 
-  workerApi: {
+  workerApi: {|
     callMaster: (
       request: CallRequest,
-      awaitResponse?: boolean | null | undefined,
-    ) => Promise<unknown>;
-    // @ts-expect-error TS2749
-    createReverseHandle: (fn: (...args: Array<any>) => unknown) => Handle;
-    getSharedReference: (ref: SharedReference) => unknown;
-    resolveSharedReference: (value: unknown) => undefined | SharedReference;
-    // @ts-expect-error TS2749
-    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>,
+  |} = {
     callMaster: (
       request: CallRequest,
-      awaitResponse: boolean | null = true,
-    ): Promise<unknown> => this.addCall(request, awaitResponse),
-    // @ts-expect-error TS2749
-    createReverseHandle: (fn: (...args: Array<any>) => unknown): Handle =>
+      awaitResponse: ?boolean = true,
+    ): Promise<mixed> => this.addCall(request, awaitResponse),
+    createReverseHandle: (fn: (...args: Array<any>) => mixed): Handle =>
       this.createReverseHandle(fn),
-    // @ts-expect-error TS2749
-    runHandle: (handle: Handle, args: Array<any>): Promise<unknown> =>
+    runHandle: (handle: Handle, args: Array<any>): Promise<mixed> =>
       this.workerApi.callMaster({handle: handle.id, args}, true),
     getSharedReference: (ref: SharedReference) =>
       this.sharedReferences.get(ref),
-    resolveSharedReference: (value: unknown) =>
+    resolveSharedReference: (value: mixed) =>
       this.sharedReferencesByValue.get(value),
   };
 
@@ -107,6 +100,7 @@ export class Child {
   }
 
   async childInit(module: string, childId: number): Promise<void> {
+    // $FlowFixMe
     this.module = require(module);
     this.childId = childId;
 
@@ -140,7 +134,7 @@ export class Child {
       try {
         let fn = nullthrows(this.handles.get(handleId)?.fn);
         result = responseFromContent(fn(...args));
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     } else if (method === 'childInit') {
@@ -157,21 +151,21 @@ export class Child {
         }
 
         result = responseFromContent(await this.childInit(moduleName, child));
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     } else if (method === 'startProfile') {
       this.profiler = new SamplingProfiler();
       try {
         result = responseFromContent(await this.profiler.startProfiling());
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     } else if (method === 'endProfile') {
       try {
         let res = this.profiler ? await this.profiler.stopProfiling() : null;
         result = responseFromContent(res);
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     } else if (method === 'takeHeapSnapshot') {
@@ -186,7 +180,7 @@ export class Child {
               '.heapsnapshot',
           ),
         );
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     } else if (method === 'createSharedReference') {
@@ -209,17 +203,17 @@ export class Child {
     } else {
       try {
         result = responseFromContent(
-          // @ts-expect-error TS2538
+          // $FlowFixMe
           await this.module[method](this.workerApi, ...args),
         );
-      } catch (e: any) {
+      } catch (e) {
         result = errorResponseFromError(e);
       }
     }
 
     try {
       this.send(result);
-    } catch (e: any) {
+    } catch (e) {
       result = this.send(errorResponseFromError(e));
     }
   }
@@ -246,13 +240,14 @@ export class Child {
   // Keep in mind to make sure responses to these calls are JSON.Stringify safe
   addCall(
     request: CallRequest,
-    awaitResponse: boolean | null = true,
-  ): Promise<unknown> {
+    awaitResponse: ?boolean = true,
+  ): Promise<mixed> {
+    // $FlowFixMe
     let call: ChildCall = {
       ...request,
       type: 'request',
       child: this.childId,
-      // @ts-expect-error TS2322
+      // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
       awaitResponse,
       resolve: () => {},
       reject: () => {},
@@ -260,15 +255,10 @@ export class Child {
 
     let promise;
     if (awaitResponse) {
-      promise = new Promise(
-        (
-          resolve: (result: Promise<any> | any) => void,
-          reject: (error?: any) => void,
-        ) => {
-          call.resolve = resolve;
-          call.reject = reject;
-        },
-      );
+      promise = new Promise((resolve, reject) => {
+        call.resolve = resolve;
+        call.reject = reject;
+      });
     }
 
     this.callQueue.push(call);
@@ -302,7 +292,6 @@ export class Child {
     }
 
     if (this.responseQueue.size < this.maxConcurrentCalls) {
-      // @ts-expect-error TS2345
       this.sendRequest(this.callQueue.shift());
     }
   }
@@ -312,8 +301,7 @@ export class Child {
     this.tracerDisposable.dispose();
   }
 
-  // @ts-expect-error TS2749
-  createReverseHandle(fn: (...args: Array<any>) => unknown): Handle {
+  createReverseHandle(fn: (...args: Array<any>) => mixed): Handle {
     let handle = new Handle({
       fn,
       childId: this.childId,

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

@@ -1,9 +1,10 @@
+// @flow
 import type {Child} from './child';
 
 // This file is imported by both the WorkerFarm and child implementation.
 // When a worker is inited, it sets the state in this file.
 // This way, WorkerFarm can access the state without directly importing the child code.
-export let child: Child | null | undefined = null;
+export let child: ?Child = null;
 export function setChild(c: Child) {
   child = c;
 }

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

@@ -1,8 +1,7 @@
+// @flow
 import os from 'os';
 import {execSync} from 'child_process';
 
-declare const navigator: {hardwareConcurrency: number} | undefined;
-
 const exec = (command: string): string => {
   try {
     let stdout = execSync(command, {
@@ -11,7 +10,7 @@ const exec = (command: string): string => {
       stdio: [null, null, null],
     });
     return stdout.trim();
-  } catch (e: any) {
+  } catch (e) {
     return '';
   }
 };
@@ -41,25 +40,23 @@ export function detectRealCores(): number {
   return amount;
 }
 
-// @ts-expect-error TS7034
 let cores;
-export default function getCores(bypassCache: boolean = false): number {
+export default function getCores(bypassCache?: boolean = false): number {
   // Do not re-run commands if we already have the count...
-  // @ts-expect-error TS7005
   if (cores && !bypassCache) {
     return cores;
   }
 
-  // @ts-expect-error TS2339
+  // $FlowFixMe
   if (process.browser) {
-    cores = (navigator as any).hardwareConcurrency / 2;
+    // eslint-disable-next-line no-undef
+    cores = navigator.hardwareConcurrency / 2;
   }
 
-  // @ts-expect-error TS7005
   if (!cores) {
     try {
       cores = detectRealCores();
-    } catch (e: any) {
+    } catch (e) {
       // Guess the amount of real cores
       cores = os
         .cpus()

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

@@ -1,3 +1,4 @@
+// @flow
 import type {TraceEvent, LogEvent} from '@atlaspack/types-internal';
 import invariant from 'assert';
 import WorkerFarm from './WorkerFarm';

package/src/process/{ProcessChild.ts → ProcessChild.js}

@@ -1,3 +1,5 @@
+// @flow
+
 import type {
   ChildImpl,
   MessageHandler,
@@ -11,7 +13,6 @@ import nullthrows from 'nullthrows';
 import {Child} from '../child';
 import {setChild} from '../childState';
 
-// @ts-expect-error TS2420
 export default class ProcessChild implements ChildImpl {
   onMessage: MessageHandler;
   onExit: ExitHandler;
@@ -23,7 +24,6 @@ export default class ProcessChild implements ChildImpl {
 
     this.onMessage = onMessage;
     this.onExit = onExit;
-    // @ts-expect-error TS2345
     process.on('message', (data) => this.handleMessage(data));
   }
 
@@ -37,10 +37,9 @@ export default class ProcessChild implements ChildImpl {
 
   send(data: WorkerMessage) {
     let processSend = nullthrows(process.send).bind(process);
-    // @ts-expect-error TS7006
     processSend(serialize(data).toString('base64'), (err) => {
       if (err && err instanceof Error) {
-        // @ts-expect-error TS2339
+        // $FlowFixMe[prop-missing]
         if (err.code === 'ERR_IPC_CHANNEL_CLOSED') {
           // IPC connection closed
           // no need to keep the worker running if it can't send or receive data
@@ -56,5 +55,4 @@ export default class ProcessChild implements ChildImpl {
   }
 }
 
-// @ts-expect-error TS2345
 setChild(new Child(ProcessChild));

package/src/process/{ProcessWorker.ts → ProcessWorker.js}

@@ -1,3 +1,5 @@
+// @flow
+
 import type {
   WorkerImpl,
   MessageHandler,
@@ -6,29 +8,24 @@ import type {
   WorkerMessage,
 } from '../types';
 
-import childProcess, {ChildProcess} from 'child_process';
+import childProcess, {type ChildProcess} from 'child_process';
 import path from 'path';
 
 import {serialize, deserialize} from '@atlaspack/build-cache';
 
-export let WORKER_PATH: string = path.join(__dirname, 'ProcessChild.js');
-if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
-  WORKER_PATH = path.join(__dirname, 'ProcessChild.ts');
-}
+const WORKER_PATH = path.join(__dirname, './ProcessChild.js');
 
-// @ts-expect-error TS2420
 export default class ProcessWorker implements WorkerImpl {
-  execArgv: any;
+  execArgv: Object;
   onMessage: MessageHandler;
   onError: ErrorHandler;
   onExit: ExitHandler;
-  // @ts-expect-error TS2564
   child: ChildProcess;
   processQueue: boolean = true;
   sendQueue: Array<any> = [];
 
   constructor(
-    execArgv: any,
+    execArgv: Object,
     onMessage: MessageHandler,
     onError: ErrorHandler,
     onExit: ExitHandler,
@@ -60,7 +57,7 @@ export default class ProcessWorker implements WorkerImpl {
     this.child.send('die');
 
     let forceKill = setTimeout(() => this.child.kill('SIGINT'), 500);
-    await new Promise((resolve: (result: Promise<never>) => void) => {
+    await new Promise((resolve) => {
       this.child.once('exit', resolve);
     });
 

package/src/threads/{ThreadsChild.ts → ThreadsChild.js}

@@ -1,3 +1,5 @@
+// @flow
+
 import type {
   ChildImpl,
   MessageHandler,
@@ -16,7 +18,6 @@ import nullthrows from 'nullthrows';
 import {Child} from '../child';
 import {setChild} from '../childState';
 
-// @ts-expect-error TS2420
 export default class ThreadsChild implements ChildImpl {
   onMessage: MessageHandler;
   onExit: ExitHandler;
@@ -41,5 +42,4 @@ export default class ThreadsChild implements ChildImpl {
   }
 }
 
-// @ts-expect-error TS2345
 setChild(new Child(ThreadsChild));

package/src/threads/{ThreadsWorker.ts → ThreadsWorker.js}

@@ -1,3 +1,5 @@
+// @flow
+
 import type {
   WorkerImpl,
   MessageHandler,
@@ -14,22 +16,17 @@ import {
   restoreDeserializedObject,
 } from '@atlaspack/build-cache';
 
-export let WORKER_PATH: string = path.join(__dirname, 'ThreadsChild.js');
-if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
-  WORKER_PATH = path.join(__dirname, 'ThreadsChild.ts');
-}
+const WORKER_PATH = path.join(__dirname, './ThreadsChild.js');
 
-// @ts-expect-error TS2420
 export default class ThreadsWorker implements WorkerImpl {
-  execArgv: any;
+  execArgv: Object;
   onMessage: MessageHandler;
   onError: ErrorHandler;
   onExit: ExitHandler;
-  // @ts-expect-error TS2564
   worker: Worker;
 
   constructor(
-    execArgv: any,
+    execArgv: Object,
     onMessage: MessageHandler,
     onError: ErrorHandler,
     onExit: ExitHandler,
@@ -50,17 +47,14 @@ export default class ThreadsWorker implements WorkerImpl {
     this.worker.on('error', this.onError);
     this.worker.on('exit', this.onExit);
 
-    return new Promise<undefined>(
-      (resolve: (result: Promise<undefined> | undefined) => void) => {
-        this.worker.on('online', resolve);
-      },
-    );
+    return new Promise<void>((resolve) => {
+      this.worker.on('online', resolve);
+    });
   }
 
   stop(): Promise<void> {
     // In node 12, this returns a promise, but previously it accepted a callback
     // TODO: Pass a callback in earlier versions of Node
-    // @ts-expect-error TS2322
     return Promise.resolve(this.worker.terminate());
   }
 

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

@@ -1,45 +1,46 @@
+// @flow
 import type {Diagnostic} from '@atlaspack/diagnostic';
 import type {FilePath} from '@atlaspack/types-internal';
 
-export type LocationCallRequest = {
-  args: ReadonlyArray<unknown>;
-  location: string;
-  method?: string;
-};
+export type LocationCallRequest = {|
+  args: $ReadOnlyArray<mixed>,
+  location: string,
+  method?: string,
+|};
 
-export type HandleCallRequest = {
-  args: ReadonlyArray<unknown>;
-  handle: number;
-};
+export type HandleCallRequest = {|
+  args: $ReadOnlyArray<mixed>,
+  handle: number,
+|};
 
 export type CallRequest = LocationCallRequest | HandleCallRequest;
 
-export type WorkerRequest = {
-  args: ReadonlyArray<any>;
-  awaitResponse?: boolean;
-  child?: number | null | undefined;
-  idx?: number;
-  location?: FilePath;
-  method?: string | null | undefined;
-  type: 'request';
-  handle?: number;
-};
+export type WorkerRequest = {|
+  args: $ReadOnlyArray<any>,
+  awaitResponse?: boolean,
+  child?: ?number,
+  idx?: number,
+  location?: FilePath,
+  method?: ?string,
+  type: 'request',
+  handle?: number,
+|};
 
-export type WorkerDataResponse = {
-  idx?: number;
-  child?: number;
-  type: 'response';
-  contentType: 'data';
-  content: string;
-};
+export type WorkerDataResponse = {|
+  idx?: number,
+  child?: number,
+  type: 'response',
+  contentType: 'data',
+  content: string,
+|};
 
-export type WorkerErrorResponse = {
-  idx?: number;
-  child?: number;
-  type: 'response';
-  contentType: 'error';
-  content: Diagnostic | Array<Diagnostic>;
-};
+export type WorkerErrorResponse = {|
+  idx?: number,
+  child?: number,
+  type: 'response',
+  contentType: 'error',
+  content: Diagnostic | Array<Diagnostic>,
+|};
 
 export type WorkerResponse = WorkerDataResponse | WorkerErrorResponse;
 export type WorkerMessage = WorkerRequest | WorkerResponse;
@@ -49,7 +50,7 @@ export type ErrorHandler = (err: Error) => void;
 export type ExitHandler = (code: number) => void;
 export interface WorkerImpl {
   constructor(
-    execArgv: any,
+    execArgv: Object,
     onMessage: MessageHandler,
     onError: ErrorHandler,
     onExit: ExitHandler,

package/src/web/{WebChild.ts → WebChild.js}

@@ -1,3 +1,4 @@
+// @flow
 /* eslint-env worker*/
 
 import type {
@@ -15,11 +16,6 @@ import {
 import {Child} from '../child';
 import {setChild} from '../childState';
 
-// Type declarations for Web Worker environment
-declare const WorkerGlobalScope: any;
-declare const self: any;
-
-// @ts-expect-error TS2420
 export default class WebChild implements ChildImpl {
   onMessage: MessageHandler;
   onExit: ExitHandler;
@@ -41,6 +37,7 @@ export default class WebChild implements ChildImpl {
         this.onExit(0);
         self.postMessage('stopped');
       }
+      // $FlowFixMe assume WorkerMessage as data
       this.handleMessage(data);
     });
     self.postMessage('online');
@@ -55,5 +52,4 @@ export default class WebChild implements ChildImpl {
   }
 }
 
-// @ts-expect-error TS2345
 setChild(new Child(WebChild));

package/src/web/{WebWorker.ts → WebWorker.js}

@@ -1,3 +1,5 @@
+// @flow
+
 import type {
   WorkerImpl,
   MessageHandler,
@@ -14,25 +16,16 @@ import {makeDeferredWithPromise} from '@atlaspack/utils';
 
 let id = 0;
 
-// @ts-expect-error This is actually a module
-export let 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
-  WORKER_PATH = new URL('./WebChild.ts', import.meta.url);
-}
-
-// @ts-expect-error TS2420
 export default class WebWorker implements WorkerImpl {
-  execArgv: any;
+  execArgv: Object;
   onMessage: MessageHandler;
   onError: ErrorHandler;
   onExit: ExitHandler;
-  // @ts-expect-error TS2564
   worker: Worker;
-  stopping: Promise<undefined> | null | undefined;
+  stopping: ?Promise<void>;
 
   constructor(
-    execArgv: any,
+    execArgv: Object,
     onMessage: MessageHandler,
     onError: ErrorHandler,
     onExit: ExitHandler,
@@ -44,7 +37,7 @@ export default class WebWorker implements WorkerImpl {
   }
 
   start(): Promise<void> {
-    // @ts-expect-error TS1470
+    // $FlowFixMe[incompatible-call]
     this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
       name: `Parcel Worker ${id++}`,
       type: 'module',
@@ -52,33 +45,29 @@ export default class WebWorker implements WorkerImpl {
 
     let {deferred, promise} = 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(): Promise<void> {
     if (!this.stopping) {
-      // @ts-expect-error TS2322
       this.stopping = (async () => {
         this.worker.postMessage('stop');
         let {deferred, promise} = makeDeferredWithPromise();
         this.worker.addEventListener('message', ({data}: MessageEvent) => {
           if (data === 'stopped') {
-            // @ts-expect-error TS2554
             deferred.resolve();
           }
         });
@@ -87,7 +76,6 @@ export default class WebWorker implements WorkerImpl {
         this.onExit(0);
       })();
     }
-    // @ts-expect-error TS2322
     return this.stopping;
   }
 

package/test/{cpuCount.test.ts → cpuCount.test.js}

@@ -1,3 +1,4 @@
+// @flow
 import assert from 'assert';
 import os from 'os';
 

package/test/{workerfarm.test.js → workerfarm.test.cjs}

@@ -1,11 +1,9 @@
 // NOTE: @atlaspack/logger exports object instances from the module.
 // If there are issues, check all imports are using the same module instance/path
-//
-// NOTE2: @atlaspack/babel-register needs to run on the fixtures under ./integration
-// otherwise the fixtures will import "package.json#main" files rather than "package.json#source"
 const Logger = require('@atlaspack/logger').default;
 const assert = require('assert');
-const WorkerFarm = require('../src/index.ts').default;
+// eslint-disable-next-line @atlaspack/no-self-package-imports
+const WorkerFarm = require('@atlaspack/workers').default;
 
 describe('WorkerFarm', function () {
   this.timeout(30000);