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

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

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

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

@@ -1,10 +1,9 @@
-// @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;
+export let child: Child | null | undefined = null;
 export function setChild(c: Child) {
   child = c;
 }

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

@@ -1,7 +1,8 @@
-// @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, {
@@ -10,7 +11,7 @@ const exec = (command: string): string => {
       stdio: [null, null, null],
     });
     return stdout.trim();
-  } catch (e) {
+  } catch (e: any) {
     return '';
   }
 };
@@ -40,23 +41,25 @@ 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;
   }
 
-  // $FlowFixMe
+  // @ts-expect-error TS2339
   if (process.browser) {
-    // eslint-disable-next-line no-undef
-    cores = navigator.hardwareConcurrency / 2;
+    cores = (navigator as any).hardwareConcurrency / 2;
   }
 
+  // @ts-expect-error TS7005
   if (!cores) {
     try {
       cores = detectRealCores();
-    } catch (e) {
+    } catch (e: any) {
       // Guess the amount of real cores
       cores = os
         .cpus()

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

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

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   ChildImpl,
   MessageHandler,
@@ -13,6 +11,7 @@ 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;
@@ -24,6 +23,7 @@ export default class ProcessChild implements ChildImpl {
 
     this.onMessage = onMessage;
     this.onExit = onExit;
+    // @ts-expect-error TS2345
     process.on('message', (data) => this.handleMessage(data));
   }
 
@@ -37,9 +37,10 @@ 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) {
-        // $FlowFixMe[prop-missing]
+        // @ts-expect-error TS2339
         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
@@ -55,4 +56,5 @@ export default class ProcessChild implements ChildImpl {
   }
 }
 
+// @ts-expect-error TS2345
 setChild(new Child(ProcessChild));

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

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

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   ChildImpl,
   MessageHandler,
@@ -18,6 +16,7 @@ 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;
@@ -42,4 +41,5 @@ export default class ThreadsChild implements ChildImpl {
   }
 }
 
+// @ts-expect-error TS2345
 setChild(new Child(ThreadsChild));

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   WorkerImpl,
   MessageHandler,
@@ -16,17 +14,22 @@ import {
   restoreDeserializedObject,
 } from '@atlaspack/build-cache';
 
-const WORKER_PATH = path.join(__dirname, './ThreadsChild.js');
+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');
+}
 
+// @ts-expect-error TS2420
 export default class ThreadsWorker implements WorkerImpl {
-  execArgv: Object;
+  execArgv: any;
   onMessage: MessageHandler;
   onError: ErrorHandler;
   onExit: ExitHandler;
+  // @ts-expect-error TS2564
   worker: Worker;
 
   constructor(
-    execArgv: Object,
+    execArgv: any,
     onMessage: MessageHandler,
     onError: ErrorHandler,
     onExit: ExitHandler,
@@ -47,14 +50,17 @@ export default class ThreadsWorker implements WorkerImpl {
     this.worker.on('error', this.onError);
     this.worker.on('exit', this.onExit);
 
-    return new Promise<void>((resolve) => {
-      this.worker.on('online', resolve);
-    });
+    return new Promise<undefined>(
+      (resolve: (result: Promise<undefined> | undefined) => void) => {
+        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.js → types.ts}

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

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

@@ -1,4 +1,3 @@
-// @flow
 /* eslint-env worker*/
 
 import type {
@@ -16,6 +15,11 @@ 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;
@@ -37,7 +41,6 @@ export default class WebChild implements ChildImpl {
         this.onExit(0);
         self.postMessage('stopped');
       }
-      // $FlowFixMe assume WorkerMessage as data
       this.handleMessage(data);
     });
     self.postMessage('online');
@@ -52,4 +55,5 @@ export default class WebChild implements ChildImpl {
   }
 }
 
+// @ts-expect-error TS2345
 setChild(new Child(WebChild));

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   WorkerImpl,
   MessageHandler,
@@ -16,16 +14,25 @@ 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: Object;
+  execArgv: any;
   onMessage: MessageHandler;
   onError: ErrorHandler;
   onExit: ExitHandler;
+  // @ts-expect-error TS2564
   worker: Worker;
-  stopping: ?Promise<void>;
+  stopping: Promise<undefined> | null | undefined;
 
   constructor(
-    execArgv: Object,
+    execArgv: any,
     onMessage: MessageHandler,
     onError: ErrorHandler,
     onExit: ExitHandler,
@@ -37,7 +44,7 @@ export default class WebWorker implements WorkerImpl {
   }
 
   start(): Promise<void> {
-    // $FlowFixMe[incompatible-call]
+    // @ts-expect-error TS1470
     this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
       name: `Parcel Worker ${id++}`,
       type: 'module',
@@ -45,29 +52,33 @@ 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();
           }
         });
@@ -76,6 +87,7 @@ export default class WebWorker implements WorkerImpl {
         this.onExit(0);
       })();
     }
+    // @ts-expect-error TS2322
     return this.stopping;
   }
 

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

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

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

@@ -1,9 +1,11 @@
 // 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');
-// eslint-disable-next-line @atlaspack/no-self-package-imports
-const WorkerFarm = require('@atlaspack/workers').default;
+const WorkerFarm = require('../src/index.ts').default;
 
 describe('WorkerFarm', function () {
   this.timeout(30000);