@xylabs/threads 4.7.1 → 4.7.2

package/dist/master/implementation.js

@@ -1,43 +0,0 @@
-"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/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/master/index.d.ts

@@ -1,10 +0,0 @@
-import type { BlobWorker as BlobWorkerClass, Worker as WorkerType } from '../types/master';
-export { FunctionThread, ModuleThread } from '../types/master';
-export { Pool } from './pool';
-export { spawn } from './spawn';
-export { Thread } from './thread';
-export type BlobWorker = typeof BlobWorkerClass;
-export type Worker = WorkerType;
-export declare const BlobWorker: typeof BlobWorkerClass;
-export declare const Worker: typeof import("../types/master").WorkerImplementation;
-export { isWorkerRuntime } from './implementation';

package/dist/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/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/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/master/pool.d.ts

@@ -1,50 +0,0 @@
-import { Observable } from 'observable-fns';
-import type { PoolEvent, QueuedTask, TaskRunFunction } from './pool-types';
-import { PoolEventType } from './pool-types';
-import { Thread } from './thread';
-export declare namespace Pool {
-    type Event<ThreadType extends Thread = any> = PoolEvent<ThreadType>;
-    type EventType = PoolEventType;
-}
-export interface Pool<ThreadType extends Thread> {
-    completed(allowResolvingImmediately?: boolean): Promise<any>;
-    settled(allowResolvingImmediately?: boolean): Promise<Error[]>;
-    events(): Observable<PoolEvent<ThreadType>>;
-    queue<Return>(task: TaskRunFunction<ThreadType, Return>): QueuedTask<ThreadType, Return>;
-    terminate(force?: boolean): Promise<void>;
-}
-interface PoolOptions {
-    concurrency?: number;
-    maxQueuedJobs?: number;
-    name?: string;
-    size?: number;
-}
-declare class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
-    static EventType: typeof PoolEventType;
-    private readonly debug;
-    private readonly eventObservable;
-    private readonly options;
-    private readonly workers;
-    private readonly eventSubject;
-    private initErrors;
-    private isClosing;
-    private nextTaskID;
-    private taskQueue;
-    constructor(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions);
-    private findIdlingWorker;
-    private runPoolTask;
-    private run;
-    private scheduleWork;
-    private taskCompletion;
-    settled(allowResolvingImmediately?: boolean): Promise<Error[]>;
-    completed(allowResolvingImmediately?: boolean): Promise<void>;
-    events(): Observable<PoolEvent<ThreadType>>;
-    queue(taskFunction: TaskRunFunction<ThreadType, any>): QueuedTask<ThreadType, any>;
-    terminate(force?: boolean): Promise<void>;
-}
-declare function PoolConstructor<ThreadType extends Thread>(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions): WorkerPool<ThreadType>;
-export declare const Pool: typeof PoolConstructor & {
-    EventType: typeof PoolEventType;
-};
-export { PoolEvent, PoolEventType, QueuedTask, } from './pool-types';
-export { Thread } from './thread';