threadsx 2.0.2 → 2.1.0

package/esm/common.mjs

@@ -0,0 +1,20 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { DefaultSerializer, extendSerializer } from './serializers.mjs';
+
+let registeredSerializer = DefaultSerializer;
+function registerSerializer(serializer) {
+    registeredSerializer = extendSerializer(registeredSerializer, serializer);
+}
+function deserialize(message) {
+    return registeredSerializer.deserialize(message);
+}
+function serialize(input) {
+    return registeredSerializer.serialize(input);
+}
+
+export { deserialize, registerSerializer, serialize };

package/esm/errors.mjs

@@ -0,0 +1,34 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+/**
+ * Thrown when a value passed to a thread cannot be cloned by the structured
+ * clone algorithm (e.g. functions, class instances with methods, or other
+ * non-serializable values). Wraps the underlying `DataCloneError` / `DOMException`
+ * with an actionable message. Access the original error via `.cause`.
+ */
+class ThreadCloneError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.name = "ThreadCloneError";
+        this.cause = cause;
+        // Restore the prototype chain — extending built-ins breaks `instanceof`
+        // when compiled down to ES2015 without this.
+        Object.setPrototypeOf(this, ThreadCloneError.prototype);
+    }
+}
+/**
+ * Whether an error is a structured-clone failure. Both browsers and Node's
+ * `worker_threads` throw a `DOMException`/error named `"DataCloneError"` when a
+ * value cannot be cloned across the thread boundary.
+ */
+function isDataCloneError(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        error.name === "DataCloneError");
+}
+
+export { ThreadCloneError, isDataCloneError };

package/esm/index.mjs

@@ -0,0 +1,16 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+export { registerSerializer } from './common.mjs';
+export { ThreadCloneError } from './errors.mjs';
+export { BlobWorker, Worker } from './master/index.mjs';
+export { expose } from './worker/index.mjs';
+export { DefaultSerializer } from './serializers.mjs';
+export { Transfer } from './transferable.mjs';
+export { Pool } from './master/pool.mjs';
+export { Thread } from './master/thread.mjs';
+export { isWorkerRuntime } from './master/implementation.mjs';
+export { spawn } from './master/spawn.mjs';

package/esm/master/get-bundle-url.browser.mjs

@@ -0,0 +1,32 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
+let bundleURL;
+function getBundleURLCached() {
+    if (!bundleURL) {
+        bundleURL = getBundleURL();
+    }
+    return bundleURL;
+}
+function getBundleURL() {
+    // Attempt to find the URL of the current script and use that as the base URL
+    try {
+        throw new Error;
+    }
+    catch (err) {
+        const matches = ("" + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^)\n]+/g);
+        if (matches) {
+            return getBaseURL(matches[0]);
+        }
+    }
+    return "/";
+}
+function getBaseURL(url) {
+    return ("" + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/';
+}
+
+export { getBaseURL, getBundleURLCached as getBundleURL };

package/esm/master/implementation.browser.mjs

@@ -0,0 +1,76 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { getBundleURL as getBundleURLCached } from './get-bundle-url.browser.mjs';
+
+const defaultPoolSize = typeof navigator !== "undefined" && navigator.hardwareConcurrency
+    ? navigator.hardwareConcurrency
+    : 4;
+const isAbsoluteURL = (value) => /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value);
+function createSourceBlobURL(code) {
+    const blob = new Blob([code], { type: "application/javascript" });
+    return URL.createObjectURL(blob);
+}
+function selectWorkerImplementation() {
+    if (typeof Worker === "undefined") {
+        // Might happen on Safari, for instance
+        // The idea is to only fail if the constructor is actually used
+        return class NoWebWorker {
+            constructor() {
+                throw Error("No web worker implementation available. You might have tried to spawn a worker within a worker in a browser that doesn't support workers in workers.");
+            }
+        };
+    }
+    class WebWorker extends Worker {
+        constructor(url, options) {
+            var _a, _b;
+            if (typeof url === "string" && options && options._baseURL) {
+                url = new URL(url, options._baseURL);
+            }
+            else if (typeof url === "string" && !isAbsoluteURL(url) && getBundleURLCached().match(/^file:\/\//i)) {
+                url = new URL(url, getBundleURLCached().replace(/\/[^/]+$/, "/"));
+                if ((_a = options === null || options === void 0 ? void 0 : options.CORSWorkaround) !== null && _a !== void 0 ? _a : true) {
+                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+                }
+            }
+            if (typeof url === "string" && isAbsoluteURL(url)) {
+                // Create source code blob loading JS file via `importScripts()`
+                // to circumvent worker CORS restrictions
+                if ((_b = options === null || options === void 0 ? void 0 : options.CORSWorkaround) !== null && _b !== void 0 ? _b : true) {
+                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+                }
+            }
+            super(url, options);
+        }
+    }
+    class BlobWorker extends WebWorker {
+        constructor(blob, options) {
+            const url = window.URL.createObjectURL(blob);
+            super(url, options);
+        }
+        static fromText(source, options) {
+            const blob = new window.Blob([source], { type: "text/javascript" });
+            return new BlobWorker(blob, options);
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: WebWorker
+    };
+}
+let implementation;
+function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+function isWorkerRuntime() {
+    const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
+    return typeof self !== "undefined" && typeof self.postMessage === "function" && !isWindowContext;
+}
+
+export { defaultPoolSize, getWorkerImplementation, isWorkerRuntime };

package/esm/master/implementation.mjs

@@ -0,0 +1,24 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import * as implementation_browser from './implementation.browser.mjs';
+import * as implementation_node from './implementation.node.mjs';
+
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+// We alias `src/master/implementation` to `src/master/implementation.browser` for web
+// browsers already in the package.json, so if get here, it's safe to pass-through the
+// node implementation
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+const implementation = runningInNode ? implementation_node : implementation_browser;
+/** Default size of pools. Depending on the platform the value might vary from device to device. */
+const defaultPoolSize = implementation.defaultPoolSize;
+const getWorkerImplementation = implementation.getWorkerImplementation;
+/** Returns `true` if this code is currently running in a worker. */
+const isWorkerRuntime = implementation.isWorkerRuntime;
+
+export { defaultPoolSize, getWorkerImplementation, isWorkerRuntime };

package/esm/master/implementation.node.mjs

@@ -0,0 +1,190 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import getCallsites from 'callsites';
+import { cpus } from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+/// <reference lib="dom" />
+// NOTE: `callsites` is intentionally pinned to ^3. v4+ is ESM-only and would
+// break the CommonJS (dist/) build. Do not bump it to v4 without moving the
+// package to ESM-first output. (See .github/dependabot.yml, which also ignores
+// its major updates.)
+let detectedTsRuntime;
+const defaultPoolSize = cpus().length;
+/**
+ * Whether the application opted out of threadsx installing SIGINT/SIGTERM
+ * handlers (which call `process.exit()`), via `THREADS_SKIP_SIGNAL_HANDLERS`.
+ */
+function signalHandlersDisabled() {
+    const value = typeof process !== "undefined" && process.env
+        ? process.env.THREADS_SKIP_SIGNAL_HANDLERS
+        : undefined;
+    return value === "1" || value === "true";
+}
+/**
+ * Detects an available TypeScript runtime so `.ts`/`.tsx` worker files can be
+ * spawned directly during development. Prefers `tsx`, falls back to `ts-node`.
+ */
+function detectTsRuntime() {
+    if (typeof __non_webpack_require__ === "function") {
+        // Webpack build: => No TS runtime required or possible
+        return null;
+    }
+    if (detectedTsRuntime !== undefined) {
+        return detectedTsRuntime;
+    }
+    detectedTsRuntime = null;
+    for (const candidate of ["tsx", "ts-node"]) {
+        try {
+            eval("require").resolve(candidate);
+            detectedTsRuntime = candidate;
+            break;
+        }
+        catch (error) {
+            if (error && error.code === "MODULE_NOT_FOUND") {
+                continue;
+            }
+            // Re-throw
+            throw error;
+        }
+    }
+    return detectedTsRuntime;
+}
+function createTsRuntimeModule(scriptPath, runtime) {
+    const register = runtime === "tsx"
+        ? `require("tsx/cjs");`
+        : `require("ts-node/register/transpile-only");`;
+    const content = `
+    ${register}
+    require(${JSON.stringify(scriptPath)});
+  `;
+    return content;
+}
+function rebaseScriptPath(scriptPath, ignoreRegex) {
+    // An already-absolute path (e.g. from `new Worker(new URL("./w", import.meta.url))`,
+    // which threadsx normalizes to a filesystem path) must not be rebased onto the
+    // caller's directory — doing so would prepend it and corrupt the path.
+    if (path.isAbsolute(scriptPath)) {
+        return scriptPath;
+    }
+    const parentCallSite = getCallsites().find((callsite) => {
+        const filename = callsite.getFileName();
+        return Boolean(filename &&
+            !filename.match(ignoreRegex) &&
+            !filename.match(/[/\\]master[/\\]implementation/) &&
+            !filename.match(/^internal\/process/));
+    });
+    const rawCallerPath = parentCallSite ? parentCallSite.getFileName() : null;
+    let callerPath = rawCallerPath ? rawCallerPath : null;
+    if (callerPath && callerPath.startsWith('file:')) {
+        callerPath = fileURLToPath(callerPath);
+    }
+    const rebasedScriptPath = callerPath ? path.join(path.dirname(callerPath), scriptPath) : scriptPath;
+    return rebasedScriptPath;
+}
+function resolveScriptPath(scriptPath, baseURL) {
+    const makeRelative = (filePath) => {
+        // eval() hack is also webpack-related
+        return path.isAbsolute(filePath) ? filePath : path.join(baseURL || eval("__dirname"), filePath);
+    };
+    const workerFilePath = typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__.resolve(makeRelative(scriptPath))
+        : eval("require").resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)));
+    return workerFilePath;
+}
+function initWorkerThreadsWorker() {
+    // Webpack hack
+    const NativeWorker = typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__("worker_threads").Worker
+        : eval("require")("worker_threads").Worker;
+    let allWorkers = [];
+    class Worker extends NativeWorker {
+        constructor(scriptPath, options) {
+            // Bundlers like webpack 5 pass a `URL` (from `new Worker(new URL(...))`)
+            // pointing at the emitted worker chunk.
+            const normalizedScriptPath = scriptPath instanceof URL ? fileURLToPath(scriptPath) : scriptPath;
+            const resolvedScriptPath = options && options.fromSource
+                ? null
+                : resolveScriptPath(normalizedScriptPath, (options || {})._baseURL);
+            const tsRuntime = resolvedScriptPath && /\.tsx?$/i.test(resolvedScriptPath) ? detectTsRuntime() : null;
+            if (!resolvedScriptPath) {
+                // `options.fromSource` is true
+                const sourceCode = scriptPath;
+                super(sourceCode, Object.assign(Object.assign({}, options), { eval: true }));
+            }
+            else if (tsRuntime) {
+                super(createTsRuntimeModule(resolvedScriptPath, tsRuntime), Object.assign(Object.assign({}, options), { eval: true }));
+            }
+            else if (resolvedScriptPath.match(/\.asar[/\\]/)) {
+                // See <https://github.com/andywer/threads-plugin/issues/17>
+                super(resolvedScriptPath.replace(/\.asar([/\\])/, ".asar.unpacked$1"), options);
+            }
+            else {
+                super(resolvedScriptPath, options);
+            }
+            this.mappedEventListeners = new WeakMap();
+            allWorkers.push(this);
+        }
+        addEventListener(eventName, rawListener) {
+            const listener = (message) => {
+                rawListener({ data: message });
+            };
+            this.mappedEventListeners.set(rawListener, listener);
+            this.on(eventName, listener);
+        }
+        removeEventListener(eventName, rawListener) {
+            const listener = this.mappedEventListeners.get(rawListener) || rawListener;
+            this.off(eventName, listener);
+        }
+    }
+    const terminateWorkersAndMaster = () => {
+        // we should terminate all workers and then gracefully shutdown self process
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        allWorkers = [];
+    };
+    // Take care to not leave orphaned processes behind. See #147.
+    //
+    // These handlers call process.exit(), which hijacks the host application's
+    // own shutdown. Applications that manage their own graceful shutdown can opt
+    // out by setting THREADS_SKIP_SIGNAL_HANDLERS. See upstream #388 / #484.
+    if (!signalHandlersDisabled()) {
+        process.on("SIGINT", () => terminateWorkersAndMaster());
+        process.on("SIGTERM", () => terminateWorkersAndMaster());
+    }
+    class BlobWorker extends Worker {
+        constructor(blob, options) {
+            super(Buffer.from(blob).toString("utf-8"), Object.assign(Object.assign({}, options), { fromSource: true }));
+        }
+        static fromText(source, options) {
+            return new Worker(source, Object.assign(Object.assign({}, options), { fromSource: true }));
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker
+    };
+}
+let implementation;
+function selectWorkerImplementation() {
+    return initWorkerThreadsWorker();
+}
+function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+function isWorkerRuntime() {
+    // Webpack hack
+    const isMainThread = typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__("worker_threads").isMainThread
+        : eval("require")("worker_threads").isMainThread;
+    return !isMainThread;
+}
+
+export { defaultPoolSize, getWorkerImplementation, isWorkerRuntime };

package/esm/master/index.mjs

@@ -0,0 +1,17 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { getWorkerImplementation } from './implementation.mjs';
+export { isWorkerRuntime } from './implementation.mjs';
+export { Pool } from './pool.mjs';
+export { spawn } from './spawn.mjs';
+
+/** Separate class to spawn workers from source code blobs or strings. */
+const BlobWorker = getWorkerImplementation().blob;
+/** Worker implementation. Either web worker or a node.js Worker class. */
+const Worker = getWorkerImplementation().default;
+
+export { BlobWorker, Worker };

package/esm/master/invocation-proxy.mjs

@@ -0,0 +1,164 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import DebugLogger from 'debug';
+import { multicast, Observable } from 'observable-fns';
+import { serialize, deserialize } from '../common.mjs';
+import { isDataCloneError, ThreadCloneError } from '../errors.mjs';
+import { ObservablePromise } from '../observable-promise.mjs';
+import { isTransferDescriptor } from '../transferable.mjs';
+import { MasterMessageType, WorkerMessageType } from '../types/messages.mjs';
+
+/*
+ * This source file contains the code for proxying calls in the master thread to calls in the workers
+ * by `.postMessage()`-ing.
+ *
+ * Keep in mind that this code can make or break the program's performance! Need to optimize more…
+ */
+const debugMessages = DebugLogger("threads:master:messages");
+let nextJobUID = 1;
+const dedupe = (array) => Array.from(new Set(array));
+const isJobErrorMessage = (data) => data && data.type === WorkerMessageType.error;
+const isJobResultMessage = (data) => data && data.type === WorkerMessageType.result;
+const isJobStartMessage = (data) => data && data.type === WorkerMessageType.running;
+function createObservableForJob(worker, jobUID) {
+    return new Observable(observer => {
+        let asyncType;
+        let settled = false;
+        const cleanup = () => {
+            worker.removeEventListener("message", messageHandler);
+            worker.removeEventListener("error", errorHandler);
+            worker.removeEventListener("exit", exitHandler);
+        };
+        const messageHandler = ((event) => {
+            debugMessages("Message from worker:", event.data);
+            if (!event.data || event.data.uid !== jobUID)
+                return;
+            if (isJobStartMessage(event.data)) {
+                asyncType = event.data.resultType;
+            }
+            else if (isJobResultMessage(event.data)) {
+                if (asyncType === "promise") {
+                    if (typeof event.data.payload !== "undefined") {
+                        observer.next(deserialize(event.data.payload));
+                    }
+                    settled = true;
+                    observer.complete();
+                    cleanup();
+                }
+                else {
+                    if (typeof event.data.payload !== "undefined") {
+                        observer.next(deserialize(event.data.payload));
+                    }
+                    if (event.data.complete) {
+                        settled = true;
+                        observer.complete();
+                        cleanup();
+                    }
+                }
+            }
+            else if (isJobErrorMessage(event.data)) {
+                const error = deserialize(event.data.error);
+                settled = true;
+                observer.error(error);
+                cleanup();
+            }
+        });
+        // If the worker crashes or is terminated before the job produces a result,
+        // reject the pending job instead of leaving the promise hanging forever.
+        // See #386.
+        const errorHandler = ((event) => {
+            if (settled)
+                return;
+            settled = true;
+            const error = event && event.data instanceof Error
+                ? event.data
+                : Error(String((event && event.data) || "Worker errored before the job completed."));
+            observer.error(error);
+            cleanup();
+        });
+        const exitHandler = ((event) => {
+            if (settled)
+                return;
+            settled = true;
+            const exitCode = event ? event.data : undefined;
+            observer.error(Error(`Worker terminated before the job completed (exit code: ${exitCode}).`));
+            cleanup();
+        });
+        worker.addEventListener("message", messageHandler);
+        worker.addEventListener("error", errorHandler);
+        worker.addEventListener("exit", exitHandler);
+        return () => {
+            if (asyncType === "observable" || !asyncType) {
+                const cancelMessage = {
+                    type: MasterMessageType.cancel,
+                    uid: jobUID
+                };
+                worker.postMessage(cancelMessage);
+            }
+            cleanup();
+        };
+    });
+}
+function prepareArguments(rawArgs) {
+    if (rawArgs.length === 0) {
+        // Exit early if possible
+        return {
+            args: [],
+            transferables: []
+        };
+    }
+    const args = [];
+    const transferables = [];
+    for (const arg of rawArgs) {
+        if (isTransferDescriptor(arg)) {
+            args.push(serialize(arg.send));
+            transferables.push(...arg.transferables);
+        }
+        else {
+            args.push(serialize(arg));
+        }
+    }
+    return {
+        args,
+        transferables: transferables.length === 0 ? transferables : dedupe(transferables)
+    };
+}
+function createProxyFunction(worker, method) {
+    return ((...rawArgs) => {
+        const uid = nextJobUID++;
+        const { args, transferables } = prepareArguments(rawArgs);
+        const runMessage = {
+            type: MasterMessageType.run,
+            uid,
+            method,
+            args
+        };
+        debugMessages("Sending command to run function to worker:", runMessage);
+        try {
+            worker.postMessage(runMessage, transferables);
+        }
+        catch (error) {
+            if (isDataCloneError(error)) {
+                const cloneError = new ThreadCloneError(`Cannot send arguments to the worker thread: a value is not structured-cloneable. ` +
+                    `Functions, class instances and other non-serializable values cannot be passed to a thread. ` +
+                    `Original error: ${error.message}`, error);
+                return ObservablePromise.from(Promise.reject(cloneError));
+            }
+            return ObservablePromise.from(Promise.reject(error));
+        }
+        return ObservablePromise.from(multicast(createObservableForJob(worker, uid)));
+    });
+}
+function createProxyModule(worker, methodNames) {
+    const proxy = {};
+    for (const methodName of methodNames) {
+        proxy[methodName] = createProxyFunction(worker, methodName);
+    }
+    return proxy;
+}
+
+export { createProxyFunction, createProxyModule };

package/esm/master/pool-types.mjs

@@ -0,0 +1,20 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+/** Pool event type. Specifies the type of each `PoolEvent`. */
+var PoolEventType;
+(function (PoolEventType) {
+    PoolEventType["initialized"] = "initialized";
+    PoolEventType["taskCanceled"] = "taskCanceled";
+    PoolEventType["taskCompleted"] = "taskCompleted";
+    PoolEventType["taskFailed"] = "taskFailed";
+    PoolEventType["taskQueued"] = "taskQueued";
+    PoolEventType["taskQueueDrained"] = "taskQueueDrained";
+    PoolEventType["taskStart"] = "taskStart";
+    PoolEventType["terminated"] = "terminated";
+})(PoolEventType || (PoolEventType = {}));
+
+export { PoolEventType };