@atlaspack/workers 2.14.5-canary.137 → 2.14.5-canary.139

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @atlaspack/workers
 
+## 2.14.21
+
+### Patch Changes
+
+- Updated dependencies [[`069de47`](https://github.com/atlassian-labs/atlaspack/commit/069de478e64fb5889f6f2ce023eb510782767fbd)]:
+  - @atlaspack/types-internal@2.16.0
+  - @atlaspack/profiler@2.14.18
+  - @atlaspack/utils@2.17.3
+
 ## 2.14.20
 
 ### Patch Changes

package/index.d.ts

@@ -1,5 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import type {FilePath} from '@atlaspack/types';
+import type EventEmitter from 'events';
 
 type BackendType = 'process' | 'threads';
 
@@ -15,10 +16,101 @@ export type FarmOptions = {
   shouldTrace?: boolean;
 };
 
-declare class WorkerFarm {
-  constructor(options: FarmOptions);
+export class Bus extends EventEmitter {
+  emit(event: string, ...args: Array<any>): boolean;
+}
+
+export const bus: Bus;
 
+export declare class WorkerFarm {
+  ending: boolean;
+  workerApi: {
+    callChild: (
+      childId: number,
+      request: HandleCallRequest,
+    ) => Promise<unknown>;
+    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>;
+  };
+  constructor(options: Partial<FarmOptions>);
+  createSharedReference(
+    value: unknown,
+    isCacheable?: boolean,
+  ): {
+    ref: SharedReference;
+    dispose(): Promise<unknown>;
+  };
+  startProfile(): Promise<void>;
+  endProfile(): Promise<void>;
+  takeHeapSnapshot(): Promise<void>;
+  createHandle(method: string, useMainThread?: boolean): HandleFunction;
+  createReverseHandle(fn: HandleFunction): Handle;
+  callAllWorkers(method: string, args: Array<any>): Promise<void>;
+  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>;
+  };
   end(): Promise<void>;
+  static isWorker(): boolean;
 }
 
 export default WorkerFarm;
+
+export type SharedReference = number;
+
+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 HandleFunction = (...args: Array<any>) => any;
+
+export type LocationCallRequest = {
+  args: ReadonlyArray<unknown>;
+  location: string;
+  method?: string;
+};
+
+export type HandleCallRequest = {
+  args: ReadonlyArray<unknown>;
+  handle: number;
+};
+
+export type CallRequest = LocationCallRequest | HandleCallRequest;
+
+type HandleOpts = {
+  fn?: HandleFunction;
+  childId?: number | null | undefined;
+  id?: number;
+};
+
+export declare class Handle {
+  id: number;
+  childId: number | null | undefined;
+  fn: HandleFunction | null | undefined;
+  constructor(opts: HandleOpts);
+  dispose(): void;
+  serialize(): {
+    childId: number | null | undefined;
+    id: number;
+  };
+  static deserialize(opts: HandleOpts): Handle;
+}

package/lib/Handle.d.ts

@@ -0,0 +1,19 @@
+export type HandleFunction = (...args: Array<any>) => any;
+type HandleOpts = {
+    fn?: HandleFunction;
+    childId?: number | null | undefined;
+    id?: number;
+};
+export default class Handle {
+    id: number;
+    childId: number | null | undefined;
+    fn: HandleFunction | null | undefined;
+    constructor(opts: HandleOpts);
+    dispose(): void;
+    serialize(): {
+        childId: number | null | undefined;
+        id: number;
+    };
+    static deserialize(opts: HandleOpts): Handle;
+}
+export {};

package/lib/Handle.js

@@ -13,10 +13,7 @@ function _buildCache() {
 }
 var _package = _interopRequireDefault(require("../package.json"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// $FlowFixMe
 let HANDLE_ID = 0;
-// $FlowFixMe
-
 const handleById = new Map();
 class Handle {
   constructor(opts) {

package/lib/Worker.d.ts

@@ -0,0 +1,40 @@
+import type { FilePath } from '@atlaspack/types-internal';
+import type { BackendType, WorkerImpl, WorkerMessage } from './types';
+import type { SharedReference } from './WorkerFarm';
+import EventEmitter from 'events';
+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 default class Worker extends EventEmitter {
+    readonly options: WorkerOpts;
+    worker: WorkerImpl;
+    id: number;
+    sentSharedReferences: Set<SharedReference>;
+    calls: Map<number, WorkerCall>;
+    exitCode: number | null | undefined;
+    callId: number;
+    ready: boolean;
+    stopped: boolean;
+    isStopping: boolean;
+    constructor(options: WorkerOpts);
+    fork(forkModule: FilePath): Promise<void>;
+    sendSharedReference(ref: SharedReference, value: unknown): Promise<any>;
+    send(data: WorkerMessage): void;
+    call(call: WorkerCall): void;
+    receive(message: WorkerMessage): void;
+    stop(): Promise<void>;
+}
+export {};

package/lib/Worker.js

@@ -29,6 +29,8 @@ var _backend = require("./backend");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 let WORKER_ID = 0;
 class Worker extends _events().default {
+  // @ts-expect-error TS2564
+
   id = WORKER_ID++;
   sentSharedReferences = new Set();
   calls = new Map();
@@ -105,7 +107,9 @@ class Worker extends _events().default {
     let refsShared = new Set();
     // in case more refs are created while initial refs are sending
     while (refsShared.size < sharedRefs.size) {
-      await Promise.all([...sharedRefs].filter(([ref]) => !refsShared.has(ref)).map(async ([ref, value]) => {
+      await Promise.all([...sharedRefs]
+      // @ts-expect-error TS2769
+      .filter(([ref]) => !refsShared.has(ref)).map(async ([ref, value]) => {
         await this.sendSharedReference(ref, value);
         refsShared.add(ref);
       }));
@@ -144,8 +148,10 @@ class Worker extends _events().default {
       args: call.args
     };
     if (this.ready || call.skipReadyCheck === true) {
+      // @ts-expect-error TS2345
       this.send(msg);
     } else {
+      // @ts-expect-error TS2345
       this.once('ready', () => this.send(msg));
     }
   }

package/lib/WorkerFarm.d.ts

@@ -0,0 +1,93 @@
+import type { ErrorWithCode, FilePath } from '@atlaspack/types-internal';
+import type { CallRequest, HandleCallRequest, WorkerRequest, BackendType } from './types';
+import type { HandleFunction } from './Handle';
+import EventEmitter from 'events';
+import Worker, { WorkerCall } from './Worker';
+import Handle from './Handle';
+import { SamplingProfiler } from '@atlaspack/profiler';
+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 = {
+    readonly [key: string]: (...args: Array<unknown>) => Promise<unknown>;
+};
+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 };
+/**
+ * workerPath should always be defined inside farmOptions
+ */
+export default class WorkerFarm extends EventEmitter {
+    callQueue: Array<WorkerCall>;
+    ending: boolean;
+    localWorker: WorkerModule;
+    localWorkerInit: Promise<undefined> | null | undefined;
+    options: FarmOptions;
+    run: HandleFunction;
+    warmWorkers: number;
+    readyWorkers: number;
+    workers: Map<number, Worker>;
+    handles: Map<number, Handle>;
+    sharedReferences: Map<SharedReference, unknown>;
+    sharedReferencesByValue: Map<unknown, SharedReference>;
+    serializedSharedReferences: Map<SharedReference, ArrayBuffer | null | undefined>;
+    profiler: SamplingProfiler | null | undefined;
+    constructor(farmOptions?: Partial<FarmOptions>);
+    workerApi: {
+        callChild: (childId: number, request: HandleCallRequest) => Promise<unknown>;
+        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>;
+    };
+    warmupWorker(method: string, args: Array<any>): void;
+    shouldStartRemoteWorkers(): boolean;
+    createHandle(method: string, useMainThread?: boolean): HandleFunction;
+    onError(error: ErrorWithCode, worker: Worker): undefined | Promise<undefined>;
+    startChild(): void;
+    stopWorker(worker: Worker): Promise<void>;
+    processQueue(): void;
+    callWorker(worker: Worker, call: WorkerCall): Promise<void>;
+    processRequest(data: {
+        location: FilePath;
+    } & Partial<WorkerRequest>, worker?: Worker): Promise<string | null | undefined>;
+    addCall(method: string, args: Array<any>): Promise<any>;
+    end(): Promise<void>;
+    startMaxWorkers(): void;
+    shouldUseRemoteWorkers(): boolean;
+    createReverseHandle(fn: HandleFunction): Handle;
+    createSharedReference(value: unknown, isCacheable?: boolean): {
+        ref: SharedReference;
+        dispose(): Promise<unknown>;
+    };
+    getSerializedSharedReference(ref: SharedReference): ArrayBuffer;
+    startProfile(): Promise<void>;
+    endProfile(): Promise<void>;
+    callAllWorkers(method: string, args: Array<any>): Promise<void>;
+    takeHeapSnapshot(): Promise<void>;
+    static getNumWorkers(): number;
+    static isWorker(): boolean;
+    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>;
+    };
+    static getConcurrentCallsPerWorker(defaultValue?: number): number;
+}

package/lib/WorkerFarm.js

@@ -108,9 +108,9 @@ class WorkerFarm extends _events().default {
     if (!this.options.workerPath) {
       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;
     this.run = this.createHandle('run');
 
@@ -127,9 +127,9 @@ class WorkerFarm extends _events().default {
   }
   workerApi = {
     callMaster: async (request, awaitResponse = true) => {
-      // $FlowFixMe
       let result = await this.processRequest({
         ...request,
+        // @ts-expect-error TS2322
         awaitResponse
       });
       return (0, _buildCache().deserialize)((0, _buildCache().serialize)(result));
@@ -203,6 +203,7 @@ class WorkerFarm extends _events().default {
   onError(error, worker) {
     // Handle ipc errors
     if (error.code === 'ERR_IPC_CHANNEL_CLOSED') {
+      // @ts-expect-error TS2322
       return this.stopWorker(worker);
     } else {
       _logger().default.error(error, '@atlaspack/workers');
@@ -261,6 +262,7 @@ class WorkerFarm extends _events().default {
         continue;
       }
       if (worker.calls.size < this.options.maxConcurrentCallsPerWorker) {
+        // @ts-expect-error TS2345
         this.callWorker(worker, this.callQueue.shift());
       }
     }
@@ -287,7 +289,7 @@ class WorkerFarm extends _events().default {
       var _this$handles$get;
       mod = (0, _nullthrows().default)((_this$handles$get = this.handles.get(handleId)) === null || _this$handles$get === void 0 ? void 0 : _this$handles$get.fn);
     } else if (location) {
-      // $FlowFixMe
+      // @ts-expect-error TS2339
       if (process.browser) {
         if (location === '@atlaspack/workers/bus') {
           mod = bus;
@@ -295,7 +297,6 @@ class WorkerFarm extends _events().default {
           throw new Error('No dynamic require possible: ' + location);
         }
       } else {
-        // $FlowFixMe this must be dynamic
         mod = require(location);
       }
     } else {
@@ -316,6 +317,7 @@ class WorkerFarm extends _events().default {
     let result;
     if (method == null) {
       try {
+        // @ts-expect-error TS2488
         result = responseFromContent(await mod(...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -326,7 +328,6 @@ class WorkerFarm extends _events().default {
         mod = mod.default;
       }
       try {
-        // $FlowFixMe
         result = responseFromContent(await mod[method](...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -435,8 +436,11 @@ class WorkerFarm extends _events().default {
     // 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() {
@@ -481,6 +485,7 @@ class WorkerFarm extends _events().default {
     let filename = `profile-${getTimeId()}.trace`;
     let stream = trace.pipe(_fs().default.createWriteStream(filename));
     for (let profile of profiles) {
+      // @ts-expect-error TS2345
       trace.addCPUProfile(names.shift(), profile);
     }
     trace.flush();
@@ -489,6 +494,7 @@ class WorkerFarm extends _events().default {
     });
     _logger().default.info({
       origin: '@atlaspack/workers',
+      // @ts-expect-error TS2345
       message: (0, _diagnostic().md)`Wrote profile to ${filename}`
     });
   }
@@ -523,6 +529,7 @@ class WorkerFarm extends _events().default {
       })));
       _logger().default.info({
         origin: '@atlaspack/workers',
+        // @ts-expect-error TS2345
         message: (0, _diagnostic().md)`Wrote heap snapshots to the following paths:\n${snapshotPaths.join('\n')}`
       });
     } catch {
@@ -543,7 +550,10 @@ class WorkerFarm extends _events().default {
     return _childState.child.workerApi;
   }
   static getConcurrentCallsPerWorker(defaultValue = DEFAULT_MAX_CONCURRENT_CALLS) {
-    return parseInt(process.env.ATLASPACK_MAX_CONCURRENT_CALLS, 10) || defaultValue;
+    return (
+      // @ts-expect-error TS2345
+      parseInt(process.env.ATLASPACK_MAX_CONCURRENT_CALLS, 10) || defaultValue
+    );
   }
 }
 exports.default = WorkerFarm;

package/lib/backend.d.ts

@@ -0,0 +1,4 @@
+import type { BackendType, WorkerImpl } from './types';
+export type Class<T> = new (...args: any[]) => T;
+export declare function detectBackend(): BackendType;
+export declare function getWorkerBackend(backend: BackendType): Class<WorkerImpl>;

package/lib/backend.js

@@ -5,8 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.detectBackend = detectBackend;
 exports.getWorkerBackend = getWorkerBackend;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 function detectBackend() {
-  // $FlowFixMe
+  // @ts-expect-error TS2339
   if (process.browser) return 'web';
   switch (process.env.ATLASPACK_WORKER_BACKEND) {
     case 'threads':

package/lib/bus.d.ts

@@ -0,0 +1,6 @@
+import EventEmitter from 'events';
+declare class Bus extends EventEmitter {
+    emit(event: string, ...args: Array<any>): boolean;
+}
+declare const _default: Bus;
+export default _default;

package/lib/bus.js

@@ -17,7 +17,7 @@ class Bus extends _events().default {
   emit(event, ...args) {
     if (_childState.child) {
       _childState.child.workerApi.callMaster({
-        // $FlowFixMe
+        // @ts-expect-error TS2339
         location: process.browser ? '@atlaspack/workers/bus' : __filename,
         method: 'emit',
         args: [event, ...args]

package/lib/child.d.ts

@@ -0,0 +1,43 @@
+import type { CallRequest, WorkerMessage, WorkerRequest, WorkerResponse, ChildImpl } from './types';
+import type { Async, IDisposable } from '@atlaspack/types-internal';
+import type { SharedReference } from './WorkerFarm';
+import { SamplingProfiler } from '@atlaspack/profiler';
+export type Class<T> = new (...args: any[]) => T;
+type ChildCall = WorkerRequest & {
+    resolve: (result: Promise<any> | any) => void;
+    reject: (error?: any) => void;
+};
+export declare class Child {
+    callQueue: Array<ChildCall>;
+    childId: number | null | undefined;
+    maxConcurrentCalls: number;
+    module: any | null | undefined;
+    responseId: number;
+    responseQueue: Map<number, ChildCall>;
+    loggerDisposable: IDisposable;
+    tracerDisposable: IDisposable;
+    child: ChildImpl;
+    profiler: SamplingProfiler | null | undefined;
+    handles: Map<number, Handle>;
+    sharedReferences: Map<SharedReference, unknown>;
+    sharedReferencesByValue: Map<unknown, SharedReference>;
+    constructor(ChildBackend: Class<ChildImpl>);
+    workerApi: {
+        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>;
+    };
+    messageListener(message: WorkerMessage): Async<void>;
+    send(data: WorkerMessage): void;
+    childInit(module: string, childId: number): Promise<void>;
+    handleRequest(data: WorkerRequest): Promise<void>;
+    handleResponse(data: WorkerResponse): void;
+    addCall(request: CallRequest, awaitResponse?: boolean | null): Promise<unknown>;
+    sendRequest(call: ChildCall): void;
+    processQueue(): void;
+    handleEnd(): void;
+    createReverseHandle(fn: (...args: Array<any>) => unknown): Handle;
+}
+export {};

package/lib/child.js

@@ -51,6 +51,9 @@ var _Handle2 = _interopRequireDefault(require("./Handle"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
 // The import of './Handle' should really be imported eagerly (with @babel/plugin-transform-modules-commonjs's lazy mode).
 const Handle = _Handle2.default;
 class Child {
@@ -58,6 +61,7 @@ class Child {
   maxConcurrentCalls = 10;
   responseId = 0;
   responseQueue = new Map();
+  // @ts-expect-error TS2749
   handles = new Map();
   sharedReferences = new Map();
   sharedReferencesByValue = new Map();
@@ -78,7 +82,9 @@ class Child {
   }
   workerApi = {
     callMaster: (request, awaitResponse = true) => this.addCall(request, awaitResponse),
+    // @ts-expect-error TS2749
     createReverseHandle: fn => this.createReverseHandle(fn),
+    // @ts-expect-error TS2749
     runHandle: (handle, args) => this.workerApi.callMaster({
       handle: handle.id,
       args
@@ -97,7 +103,6 @@ class Child {
     this.child.send(data);
   }
   async childInit(module, childId) {
-    // $FlowFixMe
     this.module = require(module);
     this.childId = childId;
     if (this.module.childInit != null) {
@@ -189,7 +194,7 @@ class Child {
     } else {
       try {
         result = responseFromContent(
-        // $FlowFixMe
+        // @ts-expect-error TS2538
         await this.module[method](this.workerApi, ...args));
       } catch (e) {
         result = errorResponseFromError(e);
@@ -222,12 +227,11 @@ class Child {
 
   // Keep in mind to make sure responses to these calls are JSON.Stringify safe
   addCall(request, awaitResponse = true) {
-    // $FlowFixMe
     let call = {
       ...request,
       type: 'request',
       child: this.childId,
-      // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
+      // @ts-expect-error TS2322
       awaitResponse,
       resolve: () => {},
       reject: () => {}
@@ -265,6 +269,7 @@ class Child {
       return;
     }
     if (this.responseQueue.size < this.maxConcurrentCalls) {
+      // @ts-expect-error TS2345
       this.sendRequest(this.callQueue.shift());
     }
   }
@@ -272,6 +277,8 @@ class Child {
     this.loggerDisposable.dispose();
     this.tracerDisposable.dispose();
   }
+
+  // @ts-expect-error TS2749
   createReverseHandle(fn) {
     let handle = new Handle({
       fn,

package/lib/childState.d.ts

@@ -0,0 +1,3 @@
+import type { Child } from './child';
+export declare let child: Child | null | undefined;
+export declare function setChild(c: Child): void;

package/lib/cpuCount.d.ts

@@ -0,0 +1,2 @@
+export declare function detectRealCores(): number;
+export default function getCores(bypassCache?: boolean): number;

package/lib/cpuCount.js

@@ -50,18 +50,22 @@ function detectRealCores() {
   }
   return amount;
 }
+
+// @ts-expect-error TS7034
 let cores;
 function getCores(bypassCache = false) {
   // 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;
   }
+
+  // @ts-expect-error TS7005
   if (!cores) {
     try {
       cores = detectRealCores();

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import WorkerFarm from './WorkerFarm';
+import bus from './bus';
+export default WorkerFarm;
+export { bus };
+export { Handle } from './WorkerFarm';
+export type { WorkerApi, FarmOptions, SharedReference } from './WorkerFarm';

package/lib/process/ProcessChild.d.ts

@@ -0,0 +1,9 @@
+import type { ChildImpl, MessageHandler, ExitHandler, WorkerMessage } from '../types';
+export default class ProcessChild implements ChildImpl {
+    onMessage: MessageHandler;
+    onExit: ExitHandler;
+    constructor(onMessage: MessageHandler, onExit: ExitHandler);
+    handleMessage(data: string): void;
+    send(data: WorkerMessage): void;
+    stop(): void;
+}