threadsx 2.0.0

package/dist-esm/worker/index.js

@@ -0,0 +1,215 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { deserialize, serialize } from "../common";
+import { isTransferDescriptor } from "../transferable";
+import { MasterMessageType, WorkerMessageType } from "../types/messages";
+import Implementation from "./implementation";
+export { registerSerializer } from "../common";
+export { Transfer } from "../transferable";
+/** Returns `true` if this code is currently running in a worker. */
+export const isWorkerRuntime = Implementation.isWorkerRuntime;
+let exposeCalled = false;
+const activeSubscriptions = new Map();
+const isMasterJobCancelMessage = (thing) => thing && thing.type === MasterMessageType.cancel;
+const isMasterJobRunMessage = (thing) => thing && thing.type === MasterMessageType.run;
+/**
+ * Detects observables via the `Symbol.observable` / `@@observable` interop protocol.
+ * Inlined from the `is-observable` package (which is now ESM-only) to keep the
+ * CommonJS build working without an extra dependency.
+ */
+function isInteropObservable(thing) {
+    if (!thing) {
+        return false;
+    }
+    const observableSymbol = Symbol.observable;
+    if (typeof observableSymbol === "symbol" && typeof thing[observableSymbol] === "function") {
+        return thing === thing[observableSymbol]();
+    }
+    if (typeof thing["@@observable"] === "function") {
+        return thing === thing["@@observable"]();
+    }
+    return false;
+}
+/**
+ * There are issues with interop observable detection not recognizing zen-observable's instances.
+ * We are using `observable-fns`, but it's based on zen-observable, too.
+ */
+const isObservable = (thing) => isInteropObservable(thing) || isZenObservable(thing);
+function isZenObservable(thing) {
+    return thing && typeof thing === "object" && typeof thing.subscribe === "function";
+}
+function deconstructTransfer(thing) {
+    return isTransferDescriptor(thing)
+        ? { payload: thing.send, transferables: thing.transferables }
+        : { payload: thing, transferables: undefined };
+}
+function postFunctionInitMessage() {
+    const initMessage = {
+        type: WorkerMessageType.init,
+        exposed: {
+            type: "function"
+        }
+    };
+    Implementation.postMessageToMaster(initMessage);
+}
+function postModuleInitMessage(methodNames) {
+    const initMessage = {
+        type: WorkerMessageType.init,
+        exposed: {
+            type: "module",
+            methods: methodNames
+        }
+    };
+    Implementation.postMessageToMaster(initMessage);
+}
+function postJobErrorMessage(uid, rawError) {
+    const { payload: error, transferables } = deconstructTransfer(rawError);
+    const errorMessage = {
+        type: WorkerMessageType.error,
+        uid,
+        error: serialize(error)
+    };
+    Implementation.postMessageToMaster(errorMessage, transferables);
+}
+function postJobResultMessage(uid, completed, resultValue) {
+    const { payload, transferables } = deconstructTransfer(resultValue);
+    const resultMessage = {
+        type: WorkerMessageType.result,
+        uid,
+        complete: completed ? true : undefined,
+        payload
+    };
+    Implementation.postMessageToMaster(resultMessage, transferables);
+}
+function postJobStartMessage(uid, resultType) {
+    const startMessage = {
+        type: WorkerMessageType.running,
+        uid,
+        resultType
+    };
+    Implementation.postMessageToMaster(startMessage);
+}
+function postUncaughtErrorMessage(error) {
+    try {
+        const errorMessage = {
+            type: WorkerMessageType.uncaughtError,
+            error: serialize(error)
+        };
+        Implementation.postMessageToMaster(errorMessage);
+    }
+    catch (subError) {
+        console.error("Not reporting uncaught error back to master thread as it " +
+            "occured while reporting an uncaught error already." +
+            "\nLatest error:", subError, "\nOriginal error:", error);
+    }
+}
+function runFunction(jobUID, fn, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let syncResult;
+        try {
+            syncResult = fn(...args);
+        }
+        catch (error) {
+            return postJobErrorMessage(jobUID, error);
+        }
+        const resultType = isObservable(syncResult) ? "observable" : "promise";
+        postJobStartMessage(jobUID, resultType);
+        if (isObservable(syncResult)) {
+            const subscription = syncResult.subscribe(value => postJobResultMessage(jobUID, false, serialize(value)), error => {
+                postJobErrorMessage(jobUID, serialize(error));
+                activeSubscriptions.delete(jobUID);
+            }, () => {
+                postJobResultMessage(jobUID, true);
+                activeSubscriptions.delete(jobUID);
+            });
+            activeSubscriptions.set(jobUID, subscription);
+        }
+        else {
+            try {
+                const result = yield syncResult;
+                postJobResultMessage(jobUID, true, serialize(result));
+            }
+            catch (error) {
+                postJobErrorMessage(jobUID, serialize(error));
+            }
+        }
+    });
+}
+/**
+ * Expose a function or a module (an object whose values are functions)
+ * to the main thread. Must be called exactly once in every worker thread
+ * to signal its API to the main thread.
+ *
+ * @param exposed Function or object whose values are functions
+ */
+export function expose(exposed) {
+    if (!Implementation.isWorkerRuntime()) {
+        throw Error("expose() called in the master thread.");
+    }
+    if (exposeCalled) {
+        throw Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");
+    }
+    exposeCalled = true;
+    if (typeof exposed === "function") {
+        Implementation.subscribeToMasterMessages(messageData => {
+            if (isMasterJobRunMessage(messageData) && !messageData.method) {
+                runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
+            }
+        });
+        postFunctionInitMessage();
+    }
+    else if (typeof exposed === "object" && exposed) {
+        Implementation.subscribeToMasterMessages(messageData => {
+            if (isMasterJobRunMessage(messageData) && messageData.method) {
+                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize));
+            }
+        });
+        const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === "function");
+        postModuleInitMessage(methodNames);
+    }
+    else {
+        throw Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+    }
+    Implementation.subscribeToMasterMessages(messageData => {
+        if (isMasterJobCancelMessage(messageData)) {
+            const jobUID = messageData.uid;
+            const subscription = activeSubscriptions.get(jobUID);
+            if (subscription) {
+                subscription.unsubscribe();
+                activeSubscriptions.delete(jobUID);
+            }
+        }
+    });
+}
+if (typeof self !== "undefined" && typeof self.addEventListener === "function" && Implementation.isWorkerRuntime()) {
+    self.addEventListener("error", event => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
+    });
+    self.addEventListener("unhandledrejection", event => {
+        const error = event.reason;
+        if (error && typeof error.message === "string") {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}
+if (typeof process !== "undefined" && typeof process.on === "function" && Implementation.isWorkerRuntime()) {
+    process.on("uncaughtException", (error) => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+    });
+    process.on("unhandledRejection", (error) => {
+        if (error && typeof error.message === "string") {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}

package/dist-esm/worker_threads.js

@@ -0,0 +1,13 @@
+// Webpack hack
+let implementation;
+function selectImplementation() {
+    return typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__("worker_threads")
+        : eval("require")("worker_threads");
+}
+export default function getImplementation() {
+    if (!implementation) {
+        implementation = selectImplementation();
+    }
+    return implementation;
+}

package/index.mjs

@@ -0,0 +1,4 @@
+// ESM entry for Node. Re-exports the CommonJS build (which is runtime-safe in
+// both module systems); bundlers get the tree-shakeable dist-esm/ build via the
+// "module" condition in package.json#exports.
+export * from "./dist/index.js"

package/observable.mjs

@@ -0,0 +1 @@
+export * from "./dist/observable.js"

package/package.json

@@ -0,0 +1,168 @@
+{
+  "name": "threadsx",
+  "version": "2.0.0",
+  "description": "Web workers & worker threads as simple as a function call",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist-esm/index.js",
+  "scripts": {
+    "clean": "rimraf dist/ dist-esm/",
+    "dev": "npm run clean && tsc -p tsconfig.json --watch",
+    "build": "npm run clean && npm run build:cjs && npm run build:es",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:es": "tsc -p tsconfig-esm.json",
+    "postbuild": "npm run bundle",
+    "bundle": "rollup -c -f umd --file=bundle/worker.js --name=threads --silent -- dist-esm/worker/bundle-entry.js",
+    "lint": "eslint .",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "test": "npm run lint && npm run test:library && npm run test:tooling && npm run test:browser",
+    "test:library": "ava ./test/**/*.test.ts",
+    "test:tooling": "ava ./test-tooling/**/*.test.ts",
+    "test:browser": "playwright test",
+    "test:coverage": "c8 ava ./test/**/*.test.ts",
+    "prepare": "npm run build"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "module": "./dist-esm/index.js",
+      "import": "./index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./observable": {
+      "types": "./dist/observable.d.ts",
+      "module": "./dist-esm/observable.js",
+      "import": "./observable.mjs",
+      "require": "./dist/observable.js"
+    },
+    "./register": {
+      "module": "./dist-esm/master/register.js",
+      "import": "./register.mjs",
+      "require": "./dist/master/register.js"
+    },
+    "./worker": {
+      "types": "./dist/worker/index.d.ts",
+      "module": "./dist-esm/worker/index.js",
+      "import": "./worker.mjs",
+      "require": "./dist/worker/index.js"
+    }
+  },
+  "sideEffects": [
+    "./dist*/master/register.js",
+    "./dist*/worker/index.js",
+    "./register.mjs",
+    "./worker.mjs"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jmaleonard/threadsx.git"
+  },
+  "author": "Andy Wermke (https://github.com/andywer)",
+  "bugs": {
+    "url": "https://github.com/jmaleonard/threadsx/issues"
+  },
+  "homepage": "https://threadsx.jmaleonard.com",
+  "keywords": [
+    "thread",
+    "worker",
+    "pool",
+    "spawn",
+    "isomorphic",
+    "parallel",
+    "observable",
+    "worker_threads"
+  ],
+  "dependencies": {
+    "callsites": "^3.1.0",
+    "debug": "^4.4.3",
+    "observable-fns": "^0.6.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.61.0",
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@types/debug": "^4.1.12",
+    "@types/execa": "^2.0.0",
+    "@types/node": "^20.19.0",
+    "ava": "^7.0.0",
+    "c8": "^10.1.3",
+    "esbuild": "^0.25.12",
+    "eslint": "^10.5.0",
+    "eslint-config-prettier": "^9.1.2",
+    "execa": "^4.0.3",
+    "globals": "^16.5.0",
+    "prettier": "^3.8.4",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.62.0",
+    "ts-loader": "^9.6.1",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.61.1",
+    "webpack": "^5.107.2"
+  },
+  "ava": {
+    "extensions": {
+      "ts": "module"
+    },
+    "nodeArguments": [
+      "--import=tsx"
+    ],
+    "workerThreads": false,
+    "files": [
+      "./test/**/*.test.ts",
+      "./test-tooling/**/*.test.ts"
+    ],
+    "serial": true
+  },
+  "c8": {
+    "all": true,
+    "src": [
+      "src"
+    ],
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "src/**/*.browser.ts",
+      "src/worker/bundle-entry.ts",
+      "src/types/worker.ts"
+    ],
+    "reporter": [
+      "text-summary",
+      "text",
+      "lcov"
+    ],
+    "check-coverage": true,
+    "lines": 91,
+    "branches": 80,
+    "functions": 90
+  },
+  "browser": {
+    "callsites": false,
+    "tsx": false,
+    "tsx/cjs": false,
+    "ts-node": false,
+    "ts-node/register": false,
+    "worker_threads": false,
+    "./dist/master/implementation.js": "./dist/master/implementation.browser.js",
+    "./dist/master/implementation.node.js": false,
+    "./dist/worker/implementation.js": "./dist/worker/implementation.browser.js",
+    "./dist/worker/implementation.worker_threads.js": false,
+    "./dist-esm/master/implementation.js": "./dist-esm/master/implementation.browser.js",
+    "./dist-esm/master/implementation.node.js": false,
+    "./dist-esm/worker/implementation.js": "./dist-esm/worker/implementation.browser.js",
+    "./dist-esm/worker/implementation.worker_threads.js": false
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist/**",
+    "dist-esm/**",
+    "index.mjs",
+    "observable.mjs",
+    "register.mjs",
+    "worker.mjs"
+  ]
+}

package/register.mjs

@@ -0,0 +1,2 @@
+// Side-effect only: registers the threads.js Worker as the global Worker.
+import "./dist/master/register.js"

package/worker.mjs

@@ -0,0 +1 @@
+export * from "./dist/worker/index.js"