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

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;
+}

package/lib/process/ProcessChild.js

@@ -21,6 +21,7 @@ function _nullthrows() {
 var _child = require("../child");
 var _childState = require("../childState");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS2420
 class ProcessChild {
   constructor(onMessage, onExit) {
     if (!process.send) {
@@ -28,6 +29,7 @@ class ProcessChild {
     }
     this.onMessage = onMessage;
     this.onExit = onExit;
+    // @ts-expect-error TS2345
     process.on('message', data => this.handleMessage(data));
   }
   handleMessage(data) {
@@ -38,9 +40,10 @@ class ProcessChild {
   }
   send(data) {
     let processSend = (0, _nullthrows().default)(process.send).bind(process);
+    // @ts-expect-error TS7006
     processSend((0, _buildCache().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
@@ -54,5 +57,7 @@ class ProcessChild {
     process.exit();
   }
 }
+
+// @ts-expect-error TS2345
 exports.default = ProcessChild;
 (0, _childState.setChild)(new _child.Child(ProcessChild));

package/lib/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/process/ProcessWorker.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _child_process() {
   const data = _interopRequireDefault(require("child_process"));
   _child_process = function () {
@@ -26,8 +26,15 @@ function _buildCache() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, './ProcessChild.js');
+let WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'ProcessChild.js');
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  exports.WORKER_PATH = WORKER_PATH = _path().default.join(__dirname, 'ProcessChild.ts');
+}
+
+// @ts-expect-error TS2420
 class ProcessWorker {
+  // @ts-expect-error TS2564
+
   processQueue = true;
   sendQueue = [];
   constructor(execArgv, onMessage, onError, onExit) {

package/lib/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/threads/ThreadsChild.js

@@ -28,6 +28,7 @@ function _nullthrows() {
 var _child = require("../child");
 var _childState = require("../childState");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS2420
 class ThreadsChild {
   constructor(onMessage, onExit) {
     if (_worker_threads().isMainThread || !_worker_threads().parentPort) {
@@ -45,5 +46,7 @@ class ThreadsChild {
     (0, _nullthrows().default)(_worker_threads().parentPort).postMessage((0, _buildCache().prepareForSerialization)(data));
   }
 }
+
+// @ts-expect-error TS2345
 exports.default = ThreadsChild;
 (0, _childState.setChild)(new _child.Child(ThreadsChild));

package/lib/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/threads/ThreadsWorker.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.WORKER_PATH = void 0;
 function _worker_threads() {
   const data = require("worker_threads");
   _worker_threads = function () {
@@ -26,8 +26,15 @@ function _buildCache() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, './ThreadsChild.js');
+let WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'ThreadsChild.js');
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  exports.WORKER_PATH = WORKER_PATH = _path().default.join(__dirname, 'ThreadsChild.ts');
+}
+
+// @ts-expect-error TS2420
 class ThreadsWorker {
+  // @ts-expect-error TS2564
+
   constructor(execArgv, onMessage, onError, onExit) {
     this.execArgv = execArgv;
     this.onMessage = onMessage;
@@ -49,6 +56,7 @@ class ThreadsWorker {
   stop() {
     // 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());
   }
   handleMessage(data) {

package/lib/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/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/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.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerImpl, MessageHandler, ErrorHandler, ExitHandler, WorkerMessage } from '../types';
+export declare let WORKER_PATH: import("url").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/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'
@@ -36,25 +47,28 @@ class WebWorker {
       deferred,
       promise
     } = (0, _utils().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() {
     if (!this.stopping) {
+      // @ts-expect-error TS2322
       this.stopping = (async () => {
         this.worker.postMessage('stop');
         let {
@@ -65,6 +79,7 @@ class WebWorker {
           data
         }) => {
           if (data === 'stopped') {
+            // @ts-expect-error TS2554
             deferred.resolve();
           }
         });
@@ -73,6 +88,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.21",
+  "version": "2.14.22-typescript-5ad950d33.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,24 +10,28 @@
     "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/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3",
-    "@atlaspack/diagnostic": "2.14.1",
-    "@atlaspack/logger": "2.14.13",
-    "@atlaspack/profiler": "2.14.18",
-    "@atlaspack/types-internal": "2.16.0",
-    "@atlaspack/utils": "2.17.3",
+    "@atlaspack/build-cache": "2.13.4-typescript-5ad950d33.0",
+    "@atlaspack/diagnostic": "2.14.2-typescript-5ad950d33.0",
+    "@atlaspack/logger": "2.14.14-typescript-5ad950d33.0",
+    "@atlaspack/profiler": "2.14.19-typescript-5ad950d33.0",
+    "@atlaspack/types-internal": "2.16.1-typescript-5ad950d33.0",
+    "@atlaspack/utils": "2.17.4-typescript-5ad950d33.0",
     "nullthrows": "^1.1.1"
   },
   "browser": {
     "./src/process/ProcessWorker.js": false,
     "./src/threads/ThreadsWorker.js": false
   },
-  "type": "commonjs"
-}
+  "type": "commonjs",
+  "scripts": {
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
+  },
+  "gitHead": "5ad950d33a5f2255ebeb10c04a2e84c346e2de85"
+}

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,