@xylabs/threads 4.7.0 → 4.7.1

package/dist/{types/common.d.ts → common.d.ts}

@@ -1,8 +1,4 @@
-import type { JsonSerializable, Serializer, SerializerImplementation } from './serializers.ts';
-declare global {
-    var registeredSerializer: Serializer<JsonSerializable>;
-}
+import type { JsonSerializable, SerializerImplementation } from './serializers';
 export declare function registerSerializer(serializer: SerializerImplementation<JsonSerializable>): void;
 export declare function deserialize(message: JsonSerializable): any;
 export declare function serialize(input: any): JsonSerializable;
-//# sourceMappingURL=common.d.ts.map

package/dist/common.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSerializer = registerSerializer;
+exports.deserialize = deserialize;
+exports.serialize = serialize;
+const serializers_1 = require("./serializers");
+let registeredSerializer = serializers_1.DefaultSerializer;
+function registerSerializer(serializer) {
+    registeredSerializer = (0, serializers_1.extendSerializer)(registeredSerializer, serializer);
+}
+function deserialize(message) {
+    return registeredSerializer.deserialize(message);
+}
+function serialize(input) {
+    return registeredSerializer.serialize(input);
+}

package/dist/esm/common.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSerializer = registerSerializer;
+exports.deserialize = deserialize;
+exports.serialize = serialize;
+const serializers_1 = require("./serializers");
+let registeredSerializer = serializers_1.DefaultSerializer;
+function registerSerializer(serializer) {
+    registeredSerializer = (0, serializers_1.extendSerializer)(registeredSerializer, serializer);
+}
+function deserialize(message) {
+    return registeredSerializer.deserialize(message);
+}
+function serialize(input) {
+    return registeredSerializer.serialize(input);
+}

package/dist/esm/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.Transfer = exports.DefaultSerializer = exports.registerSerializer = void 0;
+var common_1 = require("./common");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_1.registerSerializer; } });
+__exportStar(require("./master/index"), exports);
+var serializers_1 = require("./serializers");
+Object.defineProperty(exports, "DefaultSerializer", { enumerable: true, get: function () { return serializers_1.DefaultSerializer; } });
+var transferable_1 = require("./transferable");
+Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_1.Transfer; } });
+var index_1 = require("./worker/index");
+Object.defineProperty(exports, "expose", { enumerable: true, get: function () { return index_1.expose; } });

package/dist/esm/master/get-bundle-url.browser.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBundleURL = getBundleURLCached;
+let bundleURL;
+function getBundleURLCached() {
+    if (!bundleURL) {
+        bundleURL = getBundleURL();
+    }
+    return bundleURL;
+}
+function getBundleURL() {
+    try {
+        throw new Error('getBundleURL failed');
+    }
+    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') + '/';
+}

package/dist/esm/master/implementation.browser.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPoolSize = void 0;
+exports.getWorkerImplementation = getWorkerImplementation;
+exports.isWorkerRuntime = isWorkerRuntime;
+const get_bundle_url_browser_1 = require("./get-bundle-url.browser");
+exports.defaultPoolSize = typeof navigator !== 'undefined' && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
+const isAbsoluteURL = (value) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value);
+function createSourceBlobURL(code) {
+    const blob = new Blob([code], { type: 'application/javascript' });
+    return URL.createObjectURL(blob);
+}
+function selectWorkerImplementation() {
+    if (typeof Worker === 'undefined') {
+        return class NoWebWorker {
+            constructor() {
+                throw new 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) {
+            if (typeof url === 'string' && options && options._baseURL) {
+                url = new URL(url, options._baseURL);
+            }
+            else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\/\//i.test((0, get_bundle_url_browser_1.getBundleURL)())) {
+                url = new URL(url, (0, get_bundle_url_browser_1.getBundleURL)().replace(/\/[^/]+$/, '/'));
+                if (options?.CORSWorkaround ?? true) {
+                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+                }
+            }
+            if (typeof url === 'string'
+                && isAbsoluteURL(url)
+                && (options?.CORSWorkaround ?? true)) {
+                url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+            }
+            super(url, options);
+        }
+    }
+    class BlobWorker extends WebWorker {
+        constructor(blob, options) {
+            const url = globalThis.URL.createObjectURL(blob);
+            super(url, options);
+        }
+        static fromText(source, options) {
+            const blob = new globalThis.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 globalThis !== 'undefined' && typeof Window !== 'undefined' && globalThis instanceof Window;
+    return typeof globalThis !== 'undefined' && self['postMessage'] && !isWindowContext ? true : false;
+}

package/dist/esm/master/implementation.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.getWorkerImplementation = exports.defaultPoolSize = void 0;
+const BrowserImplementation = __importStar(require("./implementation.browser"));
+const NodeImplementation = __importStar(require("./implementation.node"));
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+const implementation = runningInNode ? NodeImplementation : BrowserImplementation;
+exports.defaultPoolSize = implementation.defaultPoolSize;
+exports.getWorkerImplementation = implementation.getWorkerImplementation;
+exports.isWorkerRuntime = implementation.isWorkerRuntime;

package/dist/esm/master/implementation.node.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPoolSize = void 0;
+exports.getWorkerImplementation = getWorkerImplementation;
+exports.isWorkerRuntime = isWorkerRuntime;
+const node_events_1 = require("node:events");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const callsites_3_1_0_1 = __importDefault(require("callsites-3-1-0"));
+let tsNodeAvailable;
+exports.defaultPoolSize = (0, node_os_1.cpus)().length;
+function detectTsNode() {
+    if (typeof __non_webpack_require__ === 'function') {
+        return false;
+    }
+    if (tsNodeAvailable) {
+        return tsNodeAvailable;
+    }
+    try {
+        eval('require').resolve('ts-node');
+        tsNodeAvailable = true;
+    }
+    catch (error) {
+        if (error && error.code === 'MODULE_NOT_FOUND') {
+            tsNodeAvailable = false;
+        }
+        else {
+            throw error;
+        }
+    }
+    return tsNodeAvailable;
+}
+function createTsNodeModule(scriptPath) {
+    return `
+    require("ts-node/register/transpile-only");
+    require(${JSON.stringify(scriptPath)});
+  `;
+}
+function rebaseScriptPath(scriptPath, ignoreRegex) {
+    const parentCallSite = (0, callsites_3_1_0_1.default)().find((callsite) => {
+        const filename = callsite.getFileName();
+        return Boolean(filename && !filename.match(ignoreRegex) && !/[/\\]master[/\\]implementation/.test(filename) && !/^internal\/process/.test(filename));
+    });
+    const rawCallerPath = parentCallSite ? parentCallSite.getFileName() : null;
+    let callerPath = rawCallerPath ? rawCallerPath : null;
+    if (callerPath && callerPath.startsWith('file:')) {
+        callerPath = (0, node_url_1.fileURLToPath)(callerPath);
+    }
+    return callerPath ? node_path_1.default.join(node_path_1.default.dirname(callerPath), scriptPath) : scriptPath;
+}
+function resolveScriptPath(scriptPath, baseURL) {
+    const makeRelative = (filePath) => {
+        return node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.join(baseURL || eval('__dirname'), filePath);
+    };
+    return typeof __non_webpack_require__ === 'function'
+        ? __non_webpack_require__.resolve(makeRelative(scriptPath))
+        : eval('require').resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)));
+}
+function initWorkerThreadsWorker() {
+    const NativeWorker = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads').Worker : eval('require')('worker_threads').Worker;
+    let allWorkers = [];
+    class Worker extends NativeWorker {
+        mappedEventListeners;
+        constructor(scriptPath, options) {
+            const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options || {})._baseURL);
+            if (!resolvedScriptPath) {
+                const sourceCode = scriptPath;
+                super(sourceCode, { ...options, eval: true });
+            }
+            else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+                super(createTsNodeModule(resolvedScriptPath), { ...options, eval: true });
+            }
+            else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+                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 = () => {
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        allWorkers = [];
+    };
+    process.on('SIGINT', () => terminateWorkersAndMaster());
+    process.on('SIGTERM', () => terminateWorkersAndMaster());
+    class BlobWorker extends Worker {
+        constructor(blob, options) {
+            super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true });
+        }
+        static fromText(source, options) {
+            return new Worker(source, { ...options, fromSource: true });
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker,
+    };
+}
+function initTinyWorker() {
+    const TinyWorker = require('tiny-worker');
+    let allWorkers = [];
+    class Worker extends TinyWorker {
+        emitter;
+        constructor(scriptPath, options) {
+            const resolvedScriptPath = options && options.fromSource
+                ? null
+                : process.platform === 'win32'
+                    ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
+                    : resolveScriptPath(scriptPath);
+            if (!resolvedScriptPath) {
+                const sourceCode = scriptPath;
+                super(new Function(sourceCode), [], { esm: true });
+            }
+            else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+                super(new Function(createTsNodeModule(resolveScriptPath(scriptPath))), [], { esm: true });
+            }
+            else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+                super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), [], { esm: true });
+            }
+            else {
+                super(resolvedScriptPath, [], { esm: true });
+            }
+            allWorkers.push(this);
+            this.emitter = new node_events_1.EventEmitter();
+            this.onerror = (error) => this.emitter.emit('error', error);
+            this.onmessage = (message) => this.emitter.emit('message', message);
+        }
+        addEventListener(eventName, listener) {
+            this.emitter.addListener(eventName, listener);
+        }
+        removeEventListener(eventName, listener) {
+            this.emitter.removeListener(eventName, listener);
+        }
+        terminate() {
+            allWorkers = allWorkers.filter(worker => worker !== this);
+            return super.terminate();
+        }
+    }
+    const terminateWorkersAndMaster = () => {
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        allWorkers = [];
+    };
+    process.on('SIGINT', () => terminateWorkersAndMaster());
+    process.on('SIGTERM', () => terminateWorkersAndMaster());
+    class BlobWorker extends Worker {
+        constructor(blob, options) {
+            super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true });
+        }
+        static fromText(source, options) {
+            return new Worker(source, { ...options, fromSource: true });
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker,
+    };
+}
+let implementation;
+let isTinyWorker;
+function selectWorkerImplementation() {
+    try {
+        isTinyWorker = false;
+        return initWorkerThreadsWorker();
+    }
+    catch {
+        console.debug('Node worker_threads not available. Trying to fall back to tiny-worker polyfill...');
+        isTinyWorker = true;
+        return initTinyWorker();
+    }
+}
+function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+function isWorkerRuntime() {
+    if (isTinyWorker) {
+        return self !== undefined && self['postMessage'] ? true : false;
+    }
+    else {
+        const isMainThread = typeof __non_webpack_require__ === 'function'
+            ? __non_webpack_require__('worker_threads').isMainThread
+            : eval('require')('worker_threads').isMainThread;
+        return !isMainThread;
+    }
+}

package/dist/esm/master/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.Worker = exports.BlobWorker = exports.Thread = exports.spawn = exports.Pool = void 0;
+const implementation_1 = require("./implementation");
+var pool_1 = require("./pool");
+Object.defineProperty(exports, "Pool", { enumerable: true, get: function () { return pool_1.Pool; } });
+var spawn_1 = require("./spawn");
+Object.defineProperty(exports, "spawn", { enumerable: true, get: function () { return spawn_1.spawn; } });
+var thread_1 = require("./thread");
+Object.defineProperty(exports, "Thread", { enumerable: true, get: function () { return thread_1.Thread; } });
+exports.BlobWorker = (0, implementation_1.getWorkerImplementation)().blob;
+exports.Worker = (0, implementation_1.getWorkerImplementation)().default;
+var implementation_2 = require("./implementation");
+Object.defineProperty(exports, "isWorkerRuntime", { enumerable: true, get: function () { return implementation_2.isWorkerRuntime; } });

package/dist/esm/master/invocation-proxy.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxyFunction = createProxyFunction;
+exports.createProxyModule = createProxyModule;
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const common_1 = require("../common");
+const observable_promise_1 = require("../observable-promise");
+const transferable_1 = require("../transferable");
+const messages_1 = require("../types/messages");
+const debugMessages = (0, debug_1.default)('threads:master:messages');
+let nextJobUID = 1;
+const dedupe = (array) => [...new Set(array)];
+const isJobErrorMessage = (data) => data && data.type === messages_1.WorkerMessageType.error;
+const isJobResultMessage = (data) => data && data.type === messages_1.WorkerMessageType.result;
+const isJobStartMessage = (data) => data && data.type === messages_1.WorkerMessageType.running;
+function createObservableForJob(worker, jobUID) {
+    return new observable_fns_1.Observable((observer) => {
+        let asyncType;
+        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 (event.data.payload !== undefined) {
+                        observer.next((0, common_1.deserialize)(event.data.payload));
+                    }
+                    observer.complete();
+                    worker.removeEventListener('message', messageHandler);
+                }
+                else {
+                    if (event.data.payload) {
+                        observer.next((0, common_1.deserialize)(event.data.payload));
+                    }
+                    if (event.data.complete) {
+                        observer.complete();
+                        worker.removeEventListener('message', messageHandler);
+                    }
+                }
+            }
+            else if (isJobErrorMessage(event.data)) {
+                const error = (0, common_1.deserialize)(event.data.error);
+                if (asyncType === 'promise' || !asyncType) {
+                    observer.error(error);
+                }
+                else {
+                    observer.error(error);
+                }
+                worker.removeEventListener('message', messageHandler);
+            }
+        });
+        worker.addEventListener('message', messageHandler);
+        return () => {
+            if (asyncType === 'observable' || !asyncType) {
+                const cancelMessage = {
+                    type: messages_1.MasterMessageType.cancel,
+                    uid: jobUID,
+                };
+                worker.postMessage(cancelMessage);
+            }
+            worker.removeEventListener('message', messageHandler);
+        };
+    });
+}
+function prepareArguments(rawArgs) {
+    if (rawArgs.length === 0) {
+        return {
+            args: [],
+            transferables: [],
+        };
+    }
+    const args = [];
+    const transferables = [];
+    for (const arg of rawArgs) {
+        if ((0, transferable_1.isTransferDescriptor)(arg)) {
+            args.push((0, common_1.serialize)(arg.send));
+            transferables.push(...arg.transferables);
+        }
+        else {
+            args.push((0, common_1.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 = {
+            args,
+            method,
+            type: messages_1.MasterMessageType.run,
+            uid,
+        };
+        debugMessages('Sending command to run function to worker:', runMessage);
+        try {
+            worker.postMessage(runMessage, transferables);
+        }
+        catch (error) {
+            return observable_promise_1.ObservablePromise.from(Promise.reject(error));
+        }
+        return observable_promise_1.ObservablePromise.from((0, observable_fns_1.multicast)(createObservableForJob(worker, uid)));
+    });
+}
+function createProxyModule(worker, methodNames) {
+    const proxy = {};
+    for (const methodName of methodNames) {
+        proxy[methodName] = createProxyFunction(worker, methodName);
+    }
+    return proxy;
+}

package/dist/esm/master/pool-types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolEventType = void 0;
+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 || (exports.PoolEventType = PoolEventType = {}));