@xylabs/threads 3.0.4

package/dist-esm/observable-promise.js

@@ -0,0 +1,152 @@
+/* eslint-disable unicorn/no-thenable */
+/* eslint-disable @typescript-eslint/member-ordering */
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-this-alias */
+/* eslint-disable unicorn/no-this-assignment */
+import { Observable } from 'observable-fns';
+const doNothing = () => { };
+const returnInput = (input) => input;
+const runDeferred = (fn) => Promise.resolve().then(fn);
+function fail(error) {
+    throw error;
+}
+function isThenable(thing) {
+    return thing && typeof thing.then === 'function';
+}
+/**
+ * Creates a hybrid, combining the APIs of an Observable and a Promise.
+ *
+ * It is used to proxy async process states when we are initially not sure
+ * if that async process will yield values once (-> Promise) or multiple
+ * times (-> Observable).
+ *
+ * Note that the observable promise inherits some of the observable's characteristics:
+ * The `init` function will be called *once for every time anyone subscribes to it*.
+ *
+ * If this is undesired, derive a hot observable from it using `makeHot()` and
+ * subscribe to that.
+ */
+export class ObservablePromise extends Observable {
+    [Symbol.toStringTag] = '[object ObservablePromise]';
+    initHasRun = false;
+    fulfillmentCallbacks = [];
+    rejectionCallbacks = [];
+    firstValue;
+    firstValueSet = false;
+    rejection;
+    state = 'pending';
+    constructor(init) {
+        super((originalObserver) => {
+            // tslint:disable-next-line no-this-assignment
+            const self = this;
+            const observer = {
+                ...originalObserver,
+                complete() {
+                    originalObserver.complete();
+                    self.onCompletion();
+                },
+                error(error) {
+                    originalObserver.error(error);
+                    self.onError(error);
+                },
+                next(value) {
+                    originalObserver.next(value);
+                    self.onNext(value);
+                },
+            };
+            try {
+                this.initHasRun = true;
+                return init(observer);
+            }
+            catch (error) {
+                observer.error(error);
+            }
+        });
+    }
+    onNext(value) {
+        if (!this.firstValueSet) {
+            this.firstValue = value;
+            this.firstValueSet = true;
+        }
+    }
+    onError(error) {
+        this.state = 'rejected';
+        this.rejection = error;
+        for (const onRejected of this.rejectionCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onRejected(error));
+        }
+    }
+    onCompletion() {
+        this.state = 'fulfilled';
+        for (const onFulfilled of this.fulfillmentCallbacks) {
+            // Promisifying the call to turn errors into unhandled promise rejections
+            // instead of them failing sync and cancelling the iteration
+            runDeferred(() => onFulfilled(this.firstValue));
+        }
+    }
+    then(onFulfilledRaw, onRejectedRaw) {
+        const onFulfilled = onFulfilledRaw || returnInput;
+        const onRejected = onRejectedRaw || fail;
+        let onRejectedCalled = false;
+        return new Promise((resolve, reject) => {
+            const rejectionCallback = (error) => {
+                if (onRejectedCalled)
+                    return;
+                onRejectedCalled = true;
+                try {
+                    resolve(onRejected(error));
+                }
+                catch (anotherError) {
+                    reject(anotherError);
+                }
+            };
+            const fulfillmentCallback = (value) => {
+                try {
+                    resolve(onFulfilled(value));
+                }
+                catch (error) {
+                    rejectionCallback(error);
+                }
+            };
+            if (!this.initHasRun) {
+                this.subscribe({ error: rejectionCallback });
+            }
+            if (this.state === 'fulfilled') {
+                return resolve(onFulfilled(this.firstValue));
+            }
+            if (this.state === 'rejected') {
+                onRejectedCalled = true;
+                return resolve(onRejected(this.rejection));
+            }
+            this.fulfillmentCallbacks.push(fulfillmentCallback);
+            this.rejectionCallbacks.push(rejectionCallback);
+        });
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onCompleted) {
+        const handler = onCompleted || doNothing;
+        return this.then((value) => {
+            handler();
+            return value;
+        }, () => handler());
+    }
+    static from(thing) {
+        return isThenable(thing) ?
+            new ObservablePromise((observer) => {
+                const onFulfilled = (value) => {
+                    observer.next(value);
+                    observer.complete();
+                };
+                const onRejected = (error) => {
+                    observer.error(error);
+                };
+                thing.then(onFulfilled, onRejected);
+            })
+            : super.from(thing);
+    }
+}

package/dist-esm/observable.js

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Observable } from 'observable-fns';
+const $observers = Symbol('observers');
+/**
+ * Observable subject. Implements the Observable interface, but also exposes
+ * the `next()`, `error()`, `complete()` methods to initiate observable
+ * updates "from the outside".
+ *
+ * Use `Observable.from(subject)` to derive an observable that proxies all
+ * values, errors and the completion raised on this subject, but does not
+ * expose the `next()`, `error()`, `complete()` methods.
+ */
+export class Subject extends Observable {
+    [$observers];
+    constructor() {
+        super((observer) => {
+            this[$observers] = [...(this[$observers] || []), observer];
+            const unsubscribe = () => {
+                this[$observers] = this[$observers].filter((someObserver) => someObserver !== observer);
+            };
+            return unsubscribe;
+        });
+        this[$observers] = [];
+    }
+    complete() {
+        for (const observer of this[$observers])
+            observer.complete();
+    }
+    error(error) {
+        for (const observer of this[$observers])
+            observer.error(error);
+    }
+    next(value) {
+        for (const observer of this[$observers])
+            observer.next(value);
+    }
+}
+export { Observable } from 'observable-fns';

package/dist-esm/ponyfills.js

@@ -0,0 +1,18 @@
+// Based on <https://github.com/es-shims/Promise.allSettled/blob/master/implementation.js>
+export function allSettled(values) {
+    return Promise.all(values.map((item) => {
+        const onFulfill = (value) => {
+            return { status: 'fulfilled', value };
+        };
+        const onReject = (reason) => {
+            return { reason, status: 'rejected' };
+        };
+        const itemPromise = Promise.resolve(item);
+        try {
+            return itemPromise.then(onFulfill, onReject);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }));
+}

package/dist-esm/promise.js

@@ -0,0 +1,25 @@
+// eslint-disable-next-line unicorn/no-useless-undefined
+const doNothing = () => undefined;
+/**
+ * Creates a new promise and exposes its resolver function.
+ * Use with care!
+ */
+export function createPromiseWithResolver() {
+    let alreadyResolved = false;
+    let resolvedTo;
+    let resolver = doNothing;
+    const promise = new Promise((resolve) => {
+        if (alreadyResolved) {
+            resolve(resolvedTo);
+        }
+        else {
+            resolver = resolve;
+        }
+    });
+    const exposedResolver = (value) => {
+        alreadyResolved = true;
+        resolvedTo = value;
+        resolver(resolvedTo);
+    };
+    return [promise, exposedResolver];
+}

package/dist-esm/serializers.js

@@ -0,0 +1,37 @@
+export function extendSerializer(extend, implementation) {
+    const fallbackDeserializer = extend.deserialize.bind(extend);
+    const fallbackSerializer = extend.serialize.bind(extend);
+    return {
+        deserialize(message) {
+            return implementation.deserialize(message, fallbackDeserializer);
+        },
+        serialize(input) {
+            return implementation.serialize(input, fallbackSerializer);
+        },
+    };
+}
+const DefaultErrorSerializer = {
+    deserialize(message) {
+        return Object.assign(Error(message.message), {
+            name: message.name,
+            stack: message.stack,
+        });
+    },
+    serialize(error) {
+        return {
+            __error_marker: '$$error',
+            message: error.message,
+            name: error.name,
+            stack: error.stack,
+        };
+    },
+};
+const isSerializedError = (thing) => thing && typeof thing === 'object' && '__error_marker' in thing && thing.__error_marker === '$$error';
+export const DefaultSerializer = {
+    deserialize(message) {
+        return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
+    },
+    serialize(input) {
+        return input instanceof Error ? DefaultErrorSerializer.serialize(input) : input;
+    },
+};

package/dist-esm/symbols.js

@@ -0,0 +1,5 @@
+export const $errors = Symbol('thread.errors');
+export const $events = Symbol('thread.events');
+export const $terminate = Symbol('thread.terminate');
+export const $transferable = Symbol('thread.transferable');
+export const $worker = Symbol('thread.worker');

package/dist-esm/transferable.js

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { $transferable } from './symbols';
+function isTransferable(thing) {
+    if (!thing || typeof thing !== 'object')
+        return false;
+    // Don't check too thoroughly, since the list of transferable things in JS might grow over time
+    return true;
+}
+export function isTransferDescriptor(thing) {
+    return thing && typeof thing === 'object' && thing[$transferable];
+}
+export function Transfer(payload, transferables) {
+    if (!transferables) {
+        if (!isTransferable(payload))
+            throw new Error('Not transferable');
+        transferables = [payload];
+    }
+    return {
+        [$transferable]: true,
+        send: payload,
+        transferables,
+    };
+}

package/dist-esm/types/master.js

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
+// tslint:disable max-classes-per-file
+import { $errors, $events, $terminate, $worker } from '../symbols';
+/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
+export var WorkerEventType;
+(function (WorkerEventType) {
+    WorkerEventType["internalError"] = "internalError";
+    WorkerEventType["message"] = "message";
+    WorkerEventType["termination"] = "termination";
+})(WorkerEventType || (WorkerEventType = {}));

package/dist-esm/types/messages.js

@@ -0,0 +1,17 @@
+/////////////////////////////
+// Messages sent by master:
+export var MasterMessageType;
+(function (MasterMessageType) {
+    MasterMessageType["cancel"] = "cancel";
+    MasterMessageType["run"] = "run";
+})(MasterMessageType || (MasterMessageType = {}));
+////////////////////////////
+// Messages sent by worker:
+export var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["error"] = "error";
+    WorkerMessageType["init"] = "init";
+    WorkerMessageType["result"] = "result";
+    WorkerMessageType["running"] = "running";
+    WorkerMessageType["uncaughtError"] = "uncaughtError";
+})(WorkerMessageType || (WorkerMessageType = {}));

package/dist-esm/types/worker.js

@@ -0,0 +1 @@
+export {};

package/dist-esm/worker/bundle-entry.js

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expose } from './index';
+export * from './index';
+if (typeof global !== 'undefined') {
+    ;
+    global.expose = expose;
+}
+if (typeof self !== 'undefined') {
+    ;
+    self.expose = expose;
+}

package/dist-esm/worker/implementation.browser.js

@@ -0,0 +1,26 @@
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
+// tslint:disable no-shadowed-variable
+const isWorkerRuntime = function isWorkerRuntime() {
+    const isWindowContext = self !== undefined && typeof Window !== 'undefined' && self instanceof Window;
+    return self !== undefined && self['postMessage'] && !isWindowContext ? true : false;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    self.postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const messageHandler = (messageEvent) => {
+        onMessage(messageEvent.data);
+    };
+    const unsubscribe = () => {
+        self.removeEventListener('message', messageHandler);
+    };
+    self.addEventListener('message', messageHandler);
+    return unsubscribe;
+};
+export default {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+};

package/dist-esm/worker/implementation.js

@@ -0,0 +1,19 @@
+/* eslint-disable import/no-default-export */
+// tslint:disable no-var-requires
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+import WebWorkerImplementation from './implementation.browser';
+import TinyWorkerImplementation from './implementation.tiny-worker';
+import WorkerThreadsImplementation from './implementation.worker_threads';
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+function selectNodeImplementation() {
+    try {
+        WorkerThreadsImplementation.testImplementation();
+        return WorkerThreadsImplementation;
+    }
+    catch {
+        return TinyWorkerImplementation;
+    }
+}
+export default runningInNode ? selectNodeImplementation() : WebWorkerImplementation;

package/dist-esm/worker/implementation.tiny-worker.js

@@ -0,0 +1,36 @@
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/// <reference lib="dom" />
+// tslint:disable no-shadowed-variable
+if (self === undefined) {
+    ;
+    global.self = global;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return self !== undefined && self['postMessage'] ? true : false;
+};
+const postMessageToMaster = function postMessageToMaster(data) {
+    // TODO: Warn that Transferables are not supported on first attempt to use feature
+    self.postMessage(data);
+};
+let muxingHandlerSetUp = false;
+const messageHandlers = new Set();
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    if (!muxingHandlerSetUp) {
+        // We have one multiplexing message handler as tiny-worker's
+        // addEventListener() only allows you to set a single message handler
+        self.addEventListener('message', ((event) => {
+            for (const handler of messageHandlers)
+                handler(event.data);
+        }));
+        muxingHandlerSetUp = true;
+    }
+    messageHandlers.add(onMessage);
+    const unsubscribe = () => messageHandlers.delete(onMessage);
+    return unsubscribe;
+};
+export default {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+};

package/dist-esm/worker/implementation.worker_threads.js

@@ -0,0 +1,37 @@
+import WorkerThreads from '../worker_threads';
+function assertMessagePort(port) {
+    if (!port) {
+        throw new Error('Invariant violation: MessagePort to parent is not available.');
+    }
+    return port;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return !WorkerThreads().isMainThread;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    assertMessagePort(WorkerThreads().parentPort).postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const parentPort = WorkerThreads().parentPort;
+    if (!parentPort) {
+        throw new Error('Invariant violation: MessagePort to parent is not available.');
+    }
+    const messageHandler = (message) => {
+        onMessage(message);
+    };
+    const unsubscribe = () => {
+        assertMessagePort(parentPort).off('message', messageHandler);
+    };
+    assertMessagePort(parentPort).on('message', messageHandler);
+    return unsubscribe;
+};
+function testImplementation() {
+    // Will throw if `worker_threads` are not available
+    WorkerThreads();
+}
+export default {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+    testImplementation,
+};

package/dist-esm/worker/index.js

@@ -0,0 +1,186 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import isSomeObservable from 'is-observable';
+import { deserialize, serialize } from '../common';
+import { isTransferDescriptor } from '../transferable';
+import { MasterMessageType, WorkerMessageType, } from '../types/messages';
+import Implementation from './implementation';
+export { registerSerializer } from '../common';
+export { Transfer } from '../transferable';
+/** Returns `true` if this code is currently running in a worker. */
+export const isWorkerRuntime = Implementation.isWorkerRuntime;
+let exposeCalled = false;
+const activeSubscriptions = new Map();
+const isMasterJobCancelMessage = (thing) => thing && thing.type === MasterMessageType.cancel;
+const isMasterJobRunMessage = (thing) => thing && thing.type === MasterMessageType.run;
+/**
+ * There are issues with `is-observable` not recognizing zen-observable's instances.
+ * We are using `observable-fns`, but it's based on zen-observable, too.
+ */
+const isObservable = (thing) => isSomeObservable(thing) || isZenObservable(thing);
+function isZenObservable(thing) {
+    return thing && typeof thing === 'object' && typeof thing.subscribe === 'function';
+}
+function deconstructTransfer(thing) {
+    return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined };
+}
+function postFunctionInitMessage() {
+    const initMessage = {
+        exposed: {
+            type: 'function',
+        },
+        type: WorkerMessageType.init,
+    };
+    Implementation.postMessageToMaster(initMessage);
+}
+function postModuleInitMessage(methodNames) {
+    const initMessage = {
+        exposed: {
+            methods: methodNames,
+            type: 'module',
+        },
+        type: WorkerMessageType.init,
+    };
+    Implementation.postMessageToMaster(initMessage);
+}
+function postJobErrorMessage(uid, rawError) {
+    const { payload: error, transferables } = deconstructTransfer(rawError);
+    const errorMessage = {
+        error: serialize(error),
+        type: WorkerMessageType.error,
+        uid,
+    };
+    Implementation.postMessageToMaster(errorMessage, transferables);
+}
+function postJobResultMessage(uid, completed, resultValue) {
+    const { payload, transferables } = deconstructTransfer(resultValue);
+    const resultMessage = {
+        complete: completed ? true : undefined,
+        payload,
+        type: WorkerMessageType.result,
+        uid,
+    };
+    Implementation.postMessageToMaster(resultMessage, transferables);
+}
+function postJobStartMessage(uid, resultType) {
+    const startMessage = {
+        resultType,
+        type: WorkerMessageType.running,
+        uid,
+    };
+    Implementation.postMessageToMaster(startMessage);
+}
+function postUncaughtErrorMessage(error) {
+    try {
+        const errorMessage = {
+            error: serialize(error),
+            type: WorkerMessageType.uncaughtError,
+        };
+        Implementation.postMessageToMaster(errorMessage);
+    }
+    catch (subError) {
+        // tslint:disable-next-line no-console
+        console.error('Not reporting uncaught error back to master thread as it ' + 'occured while reporting an uncaught error already.' + '\nLatest error:', subError, '\nOriginal error:', error);
+    }
+}
+async function runFunction(jobUID, fn, args) {
+    let syncResult;
+    try {
+        syncResult = fn(...args);
+    }
+    catch (error) {
+        return postJobErrorMessage(jobUID, error);
+    }
+    const resultType = isObservable(syncResult) ? 'observable' : 'promise';
+    postJobStartMessage(jobUID, resultType);
+    if (isObservable(syncResult)) {
+        const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, serialize(value)), (error) => {
+            postJobErrorMessage(jobUID, serialize(error));
+            activeSubscriptions.delete(jobUID);
+        }, () => {
+            postJobResultMessage(jobUID, true);
+            activeSubscriptions.delete(jobUID);
+        });
+        activeSubscriptions.set(jobUID, subscription);
+    }
+    else {
+        try {
+            const result = await syncResult;
+            postJobResultMessage(jobUID, true, serialize(result));
+        }
+        catch (error) {
+            postJobErrorMessage(jobUID, serialize(error));
+        }
+    }
+}
+/**
+ * Expose a function or a module (an object whose values are functions)
+ * to the main thread. Must be called exactly once in every worker thread
+ * to signal its API to the main thread.
+ *
+ * @param exposed Function or object whose values are functions
+ */
+export function expose(exposed) {
+    if (!Implementation.isWorkerRuntime()) {
+        throw new Error('expose() called in the master thread.');
+    }
+    if (exposeCalled) {
+        throw new Error('expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.');
+    }
+    exposeCalled = true;
+    if (typeof exposed === 'function') {
+        Implementation.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && !messageData.method) {
+                runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
+            }
+        });
+        postFunctionInitMessage();
+    }
+    else if (typeof exposed === 'object' && exposed) {
+        Implementation.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && messageData.method) {
+                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize));
+            }
+        });
+        const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === 'function');
+        postModuleInitMessage(methodNames);
+    }
+    else {
+        throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+    }
+    Implementation.subscribeToMasterMessages((messageData) => {
+        if (isMasterJobCancelMessage(messageData)) {
+            const jobUID = messageData.uid;
+            const subscription = activeSubscriptions.get(jobUID);
+            if (subscription) {
+                subscription.unsubscribe();
+                activeSubscriptions.delete(jobUID);
+            }
+        }
+    });
+}
+if (typeof self !== 'undefined' && typeof self.addEventListener === 'function' && Implementation.isWorkerRuntime()) {
+    self.addEventListener('error', (event) => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
+    });
+    self.addEventListener('unhandledrejection', (event) => {
+        const error = event.reason;
+        if (error && typeof error.message === 'string') {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}
+if (typeof process !== 'undefined' && typeof process.on === 'function' && Implementation.isWorkerRuntime()) {
+    process.on('uncaughtException', (error) => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+    });
+    process.on('unhandledRejection', (error) => {
+        if (error && typeof error.message === 'string') {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}

package/dist-esm/worker_threads.js

@@ -0,0 +1,14 @@
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Webpack hack
+// tslint:disable no-eval
+let implementation;
+function selectImplementation() {
+    return typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads') : eval('require')('worker_threads');
+}
+export default function getImplementation() {
+    if (!implementation) {
+        implementation = selectImplementation();
+    }
+    return implementation;
+}