@xylabs/threads 4.6.4 → 4.7.0

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

@@ -1,205 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-"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

@@ -1,121 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-"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 = {}));

package/dist/esm/master/pool.js

@@ -1,262 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Thread = exports.PoolEventType = exports.Pool = void 0;
-const debug_1 = __importDefault(require("debug"));
-const observable_fns_1 = require("observable-fns");
-const ponyfills_1 = require("../ponyfills");
-const implementation_1 = require("./implementation");
-const pool_types_1 = require("./pool-types");
-const thread_1 = require("./thread");
-let nextPoolID = 1;
-function createArray(size) {
-    const array = [];
-    for (let index = 0; index < size; index++) {
-        array.push(index);
-    }
-    return array;
-}
-function delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-function flatMap(array, mapper) {
-    return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
-}
-function slugify(text) {
-    return text.replaceAll(/\W/g, ' ').trim().replaceAll(/\s+/g, '-');
-}
-function spawnWorkers(spawnWorker, count) {
-    return createArray(count).map(() => ({
-        init: spawnWorker(),
-        runningTasks: [],
-    }));
-}
-class WorkerPool {
-    static EventType = pool_types_1.PoolEventType;
-    debug;
-    eventObservable;
-    options;
-    workers;
-    eventSubject = new observable_fns_1.Subject();
-    initErrors = [];
-    isClosing = false;
-    nextTaskID = 1;
-    taskQueue = [];
-    constructor(spawnWorker, optionsOrSize) {
-        const options = typeof optionsOrSize === 'number' ? { size: optionsOrSize } : optionsOrSize || {};
-        const { size = implementation_1.defaultPoolSize } = options;
-        this.debug = (0, debug_1.default)(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
-        this.options = options;
-        this.workers = spawnWorkers(spawnWorker, size);
-        this.eventObservable = (0, observable_fns_1.multicast)(observable_fns_1.Observable.from(this.eventSubject));
-        Promise.all(this.workers.map(worker => worker.init)).then(() => this.eventSubject.next({
-            size: this.workers.length,
-            type: pool_types_1.PoolEventType.initialized,
-        }), (error) => {
-            this.debug('Error while initializing pool worker:', error);
-            this.eventSubject.error(error);
-            this.initErrors.push(error);
-        });
-    }
-    findIdlingWorker() {
-        const { concurrency = 1 } = this.options;
-        return this.workers.find(worker => worker.runningTasks.length < concurrency);
-    }
-    async runPoolTask(worker, task) {
-        const workerID = this.workers.indexOf(worker) + 1;
-        this.debug(`Running task #${task.id} on worker #${workerID}...`);
-        this.eventSubject.next({
-            taskID: task.id,
-            type: pool_types_1.PoolEventType.taskStart,
-            workerID,
-        });
-        try {
-            const returnValue = await task.run(await worker.init);
-            this.debug(`Task #${task.id} completed successfully`);
-            this.eventSubject.next({
-                returnValue,
-                taskID: task.id,
-                type: pool_types_1.PoolEventType.taskCompleted,
-                workerID,
-            });
-        }
-        catch (error) {
-            this.debug(`Task #${task.id} failed`);
-            this.eventSubject.next({
-                error,
-                taskID: task.id,
-                type: pool_types_1.PoolEventType.taskFailed,
-                workerID,
-            });
-        }
-    }
-    async run(worker, task) {
-        const runPromise = (async () => {
-            const removeTaskFromWorkersRunningTasks = () => {
-                worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise);
-            };
-            await delay(0);
-            try {
-                await this.runPoolTask(worker, task);
-            }
-            finally {
-                removeTaskFromWorkersRunningTasks();
-                if (!this.isClosing) {
-                    this.scheduleWork();
-                }
-            }
-        })();
-        worker.runningTasks.push(runPromise);
-    }
-    scheduleWork() {
-        this.debug('Attempt de-queueing a task in order to run it...');
-        const availableWorker = this.findIdlingWorker();
-        if (!availableWorker)
-            return;
-        const nextTask = this.taskQueue.shift();
-        if (!nextTask) {
-            this.debug('Task queue is empty');
-            this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
-            return;
-        }
-        this.run(availableWorker, nextTask);
-    }
-    taskCompletion(taskID) {
-        return new Promise((resolve, reject) => {
-            const eventSubscription = this.events().subscribe((event) => {
-                if (event.type === pool_types_1.PoolEventType.taskCompleted && event.taskID === taskID) {
-                    eventSubscription.unsubscribe();
-                    resolve(event.returnValue);
-                }
-                else if (event.type === pool_types_1.PoolEventType.taskFailed && event.taskID === taskID) {
-                    eventSubscription.unsubscribe();
-                    reject(event.error);
-                }
-                else if (event.type === pool_types_1.PoolEventType.terminated) {
-                    eventSubscription.unsubscribe();
-                    reject(new Error('Pool has been terminated before task was run.'));
-                }
-            });
-        });
-    }
-    async settled(allowResolvingImmediately = false) {
-        const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks);
-        const taskFailures = [];
-        const failureSubscription = this.eventObservable.subscribe((event) => {
-            if (event.type === pool_types_1.PoolEventType.taskFailed) {
-                taskFailures.push(event.error);
-            }
-        });
-        if (this.initErrors.length > 0) {
-            throw this.initErrors[0];
-        }
-        if (allowResolvingImmediately && this.taskQueue.length === 0) {
-            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
-            return taskFailures;
-        }
-        await new Promise((resolve, reject) => {
-            const subscription = this.eventObservable.subscribe({
-                error: reject,
-                next(event) {
-                    if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
-                        subscription.unsubscribe();
-                        resolve(void 0);
-                    }
-                },
-            });
-        });
-        await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
-        failureSubscription.unsubscribe();
-        return taskFailures;
-    }
-    async completed(allowResolvingImmediately = false) {
-        const settlementPromise = this.settled(allowResolvingImmediately);
-        const earlyExitPromise = new Promise((resolve, reject) => {
-            const subscription = this.eventObservable.subscribe({
-                error: reject,
-                next(event) {
-                    if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
-                        subscription.unsubscribe();
-                        resolve(settlementPromise);
-                    }
-                    else if (event.type === pool_types_1.PoolEventType.taskFailed) {
-                        subscription.unsubscribe();
-                        reject(event.error);
-                    }
-                },
-            });
-        });
-        const errors = await Promise.race([settlementPromise, earlyExitPromise]);
-        if (errors.length > 0) {
-            throw errors[0];
-        }
-    }
-    events() {
-        return this.eventObservable;
-    }
-    queue(taskFunction) {
-        const { maxQueuedJobs = Number.POSITIVE_INFINITY } = this.options;
-        if (this.isClosing) {
-            throw new Error('Cannot schedule pool tasks after terminate() has been called.');
-        }
-        if (this.initErrors.length > 0) {
-            throw this.initErrors[0];
-        }
-        const taskID = this.nextTaskID++;
-        const taskCompletion = this.taskCompletion(taskID);
-        taskCompletion.catch((error) => {
-            this.debug(`Task #${taskID} errored:`, error);
-        });
-        const task = {
-            cancel: () => {
-                if (!this.taskQueue.includes(task))
-                    return;
-                this.taskQueue = this.taskQueue.filter(someTask => someTask !== task);
-                this.eventSubject.next({
-                    taskID: task.id,
-                    type: pool_types_1.PoolEventType.taskCanceled,
-                });
-            },
-            id: taskID,
-            run: taskFunction,
-            then: taskCompletion.then.bind(taskCompletion),
-        };
-        if (this.taskQueue.length >= maxQueuedJobs) {
-            throw new Error('Maximum number of pool tasks queued. Refusing to queue another one.\n'
-                + 'This usually happens for one of two reasons: We are either at peak '
-                + "workload right now or some tasks just won't finish, thus blocking the pool.");
-        }
-        this.debug(`Queueing task #${task.id}...`);
-        this.taskQueue.push(task);
-        this.eventSubject.next({
-            taskID: task.id,
-            type: pool_types_1.PoolEventType.taskQueued,
-        });
-        this.scheduleWork();
-        return task;
-    }
-    async terminate(force) {
-        this.isClosing = true;
-        if (!force) {
-            await this.completed(true);
-        }
-        this.eventSubject.next({
-            remainingQueue: [...this.taskQueue],
-            type: pool_types_1.PoolEventType.terminated,
-        });
-        this.eventSubject.complete();
-        await Promise.all(this.workers.map(async (worker) => thread_1.Thread.terminate(await worker.init)));
-    }
-}
-function PoolConstructor(spawnWorker, optionsOrSize) {
-    return new WorkerPool(spawnWorker, optionsOrSize);
-}
-;
-PoolConstructor.EventType = pool_types_1.PoolEventType;
-exports.Pool = PoolConstructor;
-var pool_types_2 = require("./pool-types");
-Object.defineProperty(exports, "PoolEventType", { enumerable: true, get: function () { return pool_types_2.PoolEventType; } });
-var thread_2 = require("./thread");
-Object.defineProperty(exports, "Thread", { enumerable: true, get: function () { return thread_2.Thread; } });

package/dist/esm/master/register.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("./index");
-if (typeof globalThis !== 'undefined') {
-    ;
-    globalThis.Worker = index_1.Worker;
-}
-else if (window !== undefined) {
-    ;
-    window.Worker = index_1.Worker;
-}