@atlaspack/workers 2.14.5-canary.26 → 2.14.5-canary.262

package/lib/types/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, ArrayBufferLike | 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): ArrayBufferLike;
+    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/types/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/types/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/types/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/types/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/types/cpuCount.d.ts

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

package/lib/types/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/types/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;
+}

package/lib/types/process/ProcessWorker.d.ts

@@ -0,0 +1,16 @@
+import type { WorkerImpl, MessageHandler, ErrorHandler, ExitHandler, WorkerMessage } from '../types';
+import { ChildProcess } from 'child_process';
+export declare let WORKER_PATH: string;
+export default class ProcessWorker implements WorkerImpl {
+    execArgv: any;
+    onMessage: MessageHandler;
+    onError: ErrorHandler;
+    onExit: ExitHandler;
+    child: ChildProcess;
+    processQueue: boolean;
+    sendQueue: Array<any>;
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(data: WorkerMessage): void;
+}

package/lib/types/threads/ThreadsChild.d.ts

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

package/lib/types/threads/ThreadsWorker.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerImpl, MessageHandler, ErrorHandler, ExitHandler, WorkerMessage } from '../types';
+import { Worker } from 'worker_threads';
+export declare let WORKER_PATH: string;
+export default class ThreadsWorker implements WorkerImpl {
+    execArgv: any;
+    onMessage: MessageHandler;
+    onError: ErrorHandler;
+    onExit: ExitHandler;
+    worker: Worker;
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleMessage(data: WorkerMessage): void;
+    send(data: WorkerMessage): void;
+}

package/lib/types/types.d.ts

@@ -0,0 +1,52 @@
+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 HandleCallRequest = {
+    args: ReadonlyArray<unknown>;
+    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 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 WorkerResponse = WorkerDataResponse | WorkerErrorResponse;
+export type WorkerMessage = WorkerRequest | WorkerResponse;
+export type MessageHandler = (data: WorkerMessage) => void;
+export type ErrorHandler = (err: Error) => void;
+export type ExitHandler = (code: number) => void;
+export interface WorkerImpl {
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(data: WorkerMessage): void;
+}
+export interface ChildImpl {
+    constructor(onMessage: MessageHandler, onExit: ExitHandler): void;
+    send(data: WorkerMessage): void;
+}
+export type BackendType = 'threads' | 'process' | 'web';

package/lib/types/web/WebChild.d.ts

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

package/lib/types/web/WebWorker.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerImpl, MessageHandler, ErrorHandler, ExitHandler, WorkerMessage } from '../types';
+export declare let WORKER_PATH: URL;
+export default class WebWorker implements WorkerImpl {
+    execArgv: any;
+    onMessage: MessageHandler;
+    onError: ErrorHandler;
+    onExit: ExitHandler;
+    worker: Worker;
+    stopping: Promise<undefined> | null | undefined;
+    constructor(execArgv: any, onMessage: MessageHandler, onError: ErrorHandler, onExit: ExitHandler);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleMessage(data: WorkerMessage): void;
+    send(data: WorkerMessage): void;
+}

package/lib/web/WebChild.js

@@ -14,6 +14,10 @@ function _buildCache() {
 var _child = require("../child");
 var _childState = require("../childState");
 /* eslint-env worker*/
+
+// Type declarations for Web Worker environment
+
+// @ts-expect-error TS2420
 class WebChild {
   constructor(onMessage, onExit) {
     if (!(typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)) {
@@ -28,7 +32,6 @@ class WebChild {
         this.onExit(0);
         self.postMessage('stopped');
       }
-      // $FlowFixMe assume WorkerMessage as data
       this.handleMessage(data);
     });
     self.postMessage('online');
@@ -40,5 +43,7 @@ class WebChild {
     self.postMessage((0, _buildCache().prepareForSerialization)(data));
   }
 }
+
+// @ts-expect-error TS2345
 exports.default = WebChild;
 (0, _childState.setChild)(new _child.Child(WebChild));

package/lib/web/WebWorker.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _buildCache() {
   const data = require("@atlaspack/build-cache");
   _buildCache = function () {
@@ -19,7 +19,18 @@ function _utils() {
   return data;
 }
 let id = 0;
+
+// @ts-expect-error This is actually a module
+let WORKER_PATH = exports.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
+  exports.WORKER_PATH = WORKER_PATH = new URL('./WebChild.ts', import.meta.url);
+}
+
+// @ts-expect-error TS2420
 class WebWorker {
+  // @ts-expect-error TS2564
+
   constructor(execArgv, onMessage, onError, onExit) {
     this.execArgv = execArgv;
     this.onMessage = onMessage;
@@ -27,7 +38,7 @@ class WebWorker {
     this.onExit = onExit;
   }
   start() {
-    // $FlowFixMe[incompatible-call]
+    // @ts-expect-error TS1470
     this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
       name: `Parcel Worker ${id++}`,
       type: 'module'
@@ -40,21 +51,23 @@ class WebWorker {
       data
     }) => {
       if (data === 'online') {
+        // @ts-expect-error TS2554
         deferred.resolve();
         return;
       }
-
-      // $FlowFixMe assume WorkerMessage as data
       this.handleMessage(data);
     };
+    // @ts-expect-error TS2322
     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() {
     if (!this.stopping) {
+      // @ts-expect-error TS2322
       this.stopping = (async () => {
         this.worker.postMessage('stop');
         let {
@@ -65,6 +78,7 @@ class WebWorker {
           data
         }) => {
           if (data === 'stopped') {
+            // @ts-expect-error TS2554
             deferred.resolve();
           }
         });
@@ -73,6 +87,7 @@ class WebWorker {
         this.onExit(0);
       })();
     }
+    // @ts-expect-error TS2322
     return this.stopping;
   }
   handleMessage(data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/workers",
-  "version": "2.14.5-canary.26+87211c647",
+  "version": "2.14.5-canary.262+2ae993f14",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,26 +10,19 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
-  "types": "index.d.ts",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "@atlaspack::sources": "./src/index.js",
-      "default": "./lib/index.js"
-    }
-  },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.94+87211c647",
-    "@atlaspack/diagnostic": "2.14.1-canary.94+87211c647",
-    "@atlaspack/logger": "2.14.5-canary.26+87211c647",
-    "@atlaspack/profiler": "2.14.1-canary.94+87211c647",
-    "@atlaspack/types-internal": "2.14.1-canary.94+87211c647",
-    "@atlaspack/utils": "2.14.5-canary.26+87211c647",
+    "@atlaspack/build-cache": "2.13.3-canary.330+2ae993f14",
+    "@atlaspack/diagnostic": "2.14.1-canary.330+2ae993f14",
+    "@atlaspack/logger": "2.14.5-canary.262+2ae993f14",
+    "@atlaspack/profiler": "2.14.1-canary.330+2ae993f14",
+    "@atlaspack/types-internal": "2.14.1-canary.330+2ae993f14",
+    "@atlaspack/utils": "2.14.5-canary.262+2ae993f14",
     "nullthrows": "^1.1.1"
   },
   "browser": {
@@ -37,5 +30,8 @@
     "./src/threads/ThreadsWorker.js": false
   },
   "type": "commonjs",
-  "gitHead": "87211c647df95663b4bca3af09e3b2d84500b8fa"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "2ae993f141ed1ee17a6c3489a9e347d300231a87"
+}

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

@@ -1,24 +1,21 @@
-// @flow strict-local
 import {registerSerializableClass} from '@atlaspack/build-cache';
-// $FlowFixMe
 import packageJson from '../package.json';
 
 let HANDLE_ID = 0;
-// $FlowFixMe
 export type HandleFunction = (...args: Array<any>) => any;
 
-type HandleOpts = {|
-  fn?: HandleFunction,
-  childId?: ?number,
-  id?: number,
-|};
+type HandleOpts = {
+  fn?: HandleFunction;
+  childId?: number | null | undefined;
+  id?: number;
+};
 
 const handleById: Map<number, Handle> = new Map();
 
 export default class Handle {
   id: number;
-  childId: ?number;
-  fn: ?HandleFunction;
+  childId: number | null | undefined;
+  fn: HandleFunction | null | undefined;
 
   constructor(opts: HandleOpts) {
     this.id = opts.id ?? ++HANDLE_ID;
@@ -31,7 +28,10 @@ export default class Handle {
     handleById.delete(this.id);
   }
 
-  serialize(): {|childId: ?number, id: number|} {
+  serialize(): {
+    childId: number | null | undefined;
+    id: number;
+  } {
     return {
       id: this.id,
       childId: this.childId,