@atlaspack/workers 2.14.21-typescript-80839fbd5.0 → 2.14.21-typescript-c10a7ae7b.0

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/backend.js

@@ -5,6 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.detectBackend = detectBackend;
 exports.getWorkerBackend = getWorkerBackend;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 function detectBackend() {
   // @ts-expect-error TS2339
   if (process.browser) return 'web';

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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/workers",
-  "version": "2.14.21-typescript-80839fbd5.0",
+  "version": "2.14.21-typescript-c10a7ae7b.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -12,17 +12,17 @@
   },
   "main": "lib/index.js",
   "source": "src/index.ts",
-  "types": "src/index.ts",
+  "types": "index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.4-typescript-80839fbd5.0",
-    "@atlaspack/diagnostic": "2.14.2-typescript-80839fbd5.0",
-    "@atlaspack/logger": "2.14.14-typescript-80839fbd5.0",
-    "@atlaspack/profiler": "2.14.18-typescript-80839fbd5.0",
-    "@atlaspack/types-internal": "2.15.3-typescript-80839fbd5.0",
-    "@atlaspack/utils": "2.17.3-typescript-80839fbd5.0",
+    "@atlaspack/build-cache": "2.13.4-typescript-c10a7ae7b.0",
+    "@atlaspack/diagnostic": "2.14.2-typescript-c10a7ae7b.0",
+    "@atlaspack/logger": "2.14.14-typescript-c10a7ae7b.0",
+    "@atlaspack/profiler": "2.14.18-typescript-c10a7ae7b.0",
+    "@atlaspack/types-internal": "2.15.3-typescript-c10a7ae7b.0",
+    "@atlaspack/utils": "2.17.3-typescript-c10a7ae7b.0",
     "nullthrows": "^1.1.1"
   },
   "browser": {
@@ -33,5 +33,5 @@
   "scripts": {
     "check-ts": "tsc --noEmit"
   },
-  "gitHead": "80839fbd5c6d6668c2622849856a4b25601354a8"
+  "gitHead": "c10a7ae7b0dc2c79430506d16447ff9bb9966043"
 }

package/src/backend.ts

@@ -1,6 +1,9 @@
-import {Flow} from 'flow-to-typescript-codemod';
 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
   if (process.browser) return 'web';
@@ -19,7 +22,7 @@ export function detectBackend(): BackendType {
   }
 }
 
-export function getWorkerBackend(backend: BackendType): Flow.Class<WorkerImpl> {
+export function getWorkerBackend(backend: BackendType): Class<WorkerImpl> {
   switch (backend) {
     case 'threads':
       return require('./threads/ThreadsWorker').default;

package/src/child.ts

@@ -1,5 +1,3 @@
-import {Flow} from 'flow-to-typescript-codemod';
-
 import type {
   CallRequest,
   WorkerDataResponse,
@@ -21,6 +19,10 @@ 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;
 
@@ -45,7 +47,7 @@ export class Child {
   sharedReferences: Map<SharedReference, unknown> = new Map();
   sharedReferencesByValue: Map<unknown, SharedReference> = new Map();
 
-  constructor(ChildBackend: Flow.Class<ChildImpl>) {
+  constructor(ChildBackend: Class<ChildImpl>) {
     this.child = new ChildBackend(
       (m: WorkerMessage) => {
         this.messageListener(m);