threadsx 2.0.2 → 2.1.0

package/esm/observable.mjs

@@ -0,0 +1,45 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Observable } from 'observable-fns';
+export { 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.
+ */
+class Subject extends Observable {
+    constructor() {
+        super(observer => {
+            this[$observers] = [
+                ...(this[$observers] || []),
+                observer
+            ];
+            const unsubscribe = () => {
+                this[$observers] = this[$observers].filter(someObserver => someObserver !== observer);
+            };
+            return unsubscribe;
+        });
+        this[$observers] = [];
+    }
+    complete() {
+        this[$observers].forEach(observer => observer.complete());
+    }
+    error(error) {
+        this[$observers].forEach(observer => observer.error(error));
+    }
+    next(value) {
+        this[$observers].forEach(observer => observer.next(value));
+    }
+}
+
+export { Subject };

package/esm/ponyfills.mjs

@@ -0,0 +1,26 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+// Based on <https://github.com/es-shims/Promise.allSettled/blob/master/implementation.js>
+function allSettled(values) {
+    return Promise.all(values.map(item => {
+        const onFulfill = (value) => {
+            return { status: 'fulfilled', value };
+        };
+        const onReject = (reason) => {
+            return { status: 'rejected', reason };
+        };
+        const itemPromise = Promise.resolve(item);
+        try {
+            return itemPromise.then(onFulfill, onReject);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }));
+}
+
+export { allSettled };

package/esm/promise.mjs

@@ -0,0 +1,32 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const doNothing = () => undefined;
+/**
+ * Creates a new promise and exposes its resolver function.
+ * Use with care!
+ */
+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];
+}
+
+export { createPromiseWithResolver };

package/esm/serializers.mjs

@@ -0,0 +1,55 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+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";
+const DefaultSerializer = {
+    deserialize(message) {
+        if (isSerializedError(message)) {
+            return DefaultErrorSerializer.deserialize(message);
+        }
+        else {
+            return message;
+        }
+    },
+    serialize(input) {
+        if (input instanceof Error) {
+            return DefaultErrorSerializer.serialize(input);
+        }
+        else {
+            return input;
+        }
+    }
+};
+
+export { DefaultSerializer, extendSerializer };

package/esm/symbols.mjs

@@ -0,0 +1,13 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const $errors = Symbol("thread.errors");
+const $events = Symbol("thread.events");
+const $terminate = Symbol("thread.terminate");
+const $transferable = Symbol("thread.transferable");
+const $worker = Symbol("thread.worker");
+
+export { $errors, $events, $terminate, $transferable, $worker };

package/esm/transferable.mjs

@@ -0,0 +1,31 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { $transferable } from './symbols.mjs';
+
+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;
+}
+function isTransferDescriptor(thing) {
+    return thing && typeof thing === "object" && thing[$transferable];
+}
+function Transfer(payload, transferables) {
+    if (!transferables) {
+        if (!isTransferable(payload))
+            throw Error();
+        transferables = [payload];
+    }
+    return {
+        [$transferable]: true,
+        send: payload,
+        transferables
+    };
+}
+
+export { Transfer, isTransferDescriptor };

package/esm/types/master.mjs

@@ -0,0 +1,15 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
+var WorkerEventType;
+(function (WorkerEventType) {
+    WorkerEventType["internalError"] = "internalError";
+    WorkerEventType["message"] = "message";
+    WorkerEventType["termination"] = "termination";
+})(WorkerEventType || (WorkerEventType = {}));
+
+export { WorkerEventType };

package/esm/types/messages.mjs

@@ -0,0 +1,25 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+/////////////////////////////
+// Messages sent by master:
+var MasterMessageType;
+(function (MasterMessageType) {
+    MasterMessageType["cancel"] = "cancel";
+    MasterMessageType["run"] = "run";
+})(MasterMessageType || (MasterMessageType = {}));
+////////////////////////////
+// Messages sent by worker:
+var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["error"] = "error";
+    WorkerMessageType["init"] = "init";
+    WorkerMessageType["result"] = "result";
+    WorkerMessageType["running"] = "running";
+    WorkerMessageType["uncaughtError"] = "uncaughtError";
+})(WorkerMessageType || (WorkerMessageType = {}));
+
+export { MasterMessageType, WorkerMessageType };

package/esm/worker/implementation.browser.mjs

@@ -0,0 +1,31 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+/// <reference lib="dom" />
+const isWorkerRuntime = function isWorkerRuntime() {
+    const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
+    return typeof self !== "undefined" && typeof self.postMessage === "function" && !isWindowContext;
+};
+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;
+};
+var WebWorkerImplementation = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages
+};
+
+export { WebWorkerImplementation as default };

package/esm/worker/implementation.mjs

@@ -0,0 +1,22 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import WebWorkerImplementation from './implementation.browser.mjs';
+import WorkerThreadsImplementation from './implementation.worker_threads.mjs';
+
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+function selectNodeImplementation() {
+    WorkerThreadsImplementation.testImplementation();
+    return WorkerThreadsImplementation;
+}
+var Implementation = runningInNode
+    ? selectNodeImplementation()
+    : WebWorkerImplementation;
+
+export { Implementation as default };

package/esm/worker/implementation.worker_threads.mjs

@@ -0,0 +1,46 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import getImplementation from '../worker_threads.mjs';
+
+function assertMessagePort(port) {
+    if (!port) {
+        throw Error("Invariant violation: MessagePort to parent is not available.");
+    }
+    return port;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return !getImplementation().isMainThread;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    assertMessagePort(getImplementation().parentPort).postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const parentPort = getImplementation().parentPort;
+    if (!parentPort) {
+        throw 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
+    getImplementation();
+}
+var WorkerThreadsImplementation = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+    testImplementation
+};
+
+export { WorkerThreadsImplementation as default };

package/esm/worker/index.mjs

@@ -0,0 +1,224 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { serialize, deserialize } from '../common.mjs';
+export { registerSerializer } from '../common.mjs';
+import { isTransferDescriptor } from '../transferable.mjs';
+export { Transfer } from '../transferable.mjs';
+import { WorkerMessageType, MasterMessageType } from '../types/messages.mjs';
+import Implementation from './implementation.mjs';
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/** Returns `true` if this code is currently running in a worker. */
+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;
+/**
+ * Detects observables via the `Symbol.observable` / `@@observable` interop protocol.
+ * Inlined from the `is-observable` package (which is now ESM-only) to keep the
+ * CommonJS build working without an extra dependency.
+ */
+function isInteropObservable(thing) {
+    if (!thing) {
+        return false;
+    }
+    const observableSymbol = Symbol.observable;
+    if (typeof observableSymbol === "symbol" && typeof thing[observableSymbol] === "function") {
+        return thing === thing[observableSymbol]();
+    }
+    if (typeof thing["@@observable"] === "function") {
+        return thing === thing["@@observable"]();
+    }
+    return false;
+}
+/**
+ * There are issues with interop observable detection not recognizing zen-observable's instances.
+ * We are using `observable-fns`, but it's based on zen-observable, too.
+ */
+const isObservable = (thing) => isInteropObservable(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 = {
+        type: WorkerMessageType.init,
+        exposed: {
+            type: "function"
+        }
+    };
+    Implementation.postMessageToMaster(initMessage);
+}
+function postModuleInitMessage(methodNames) {
+    const initMessage = {
+        type: WorkerMessageType.init,
+        exposed: {
+            type: "module",
+            methods: methodNames
+        }
+    };
+    Implementation.postMessageToMaster(initMessage);
+}
+function postJobErrorMessage(uid, rawError) {
+    const { payload: error, transferables } = deconstructTransfer(rawError);
+    const errorMessage = {
+        type: WorkerMessageType.error,
+        uid,
+        error: serialize(error)
+    };
+    Implementation.postMessageToMaster(errorMessage, transferables);
+}
+function postJobResultMessage(uid, completed, resultValue) {
+    const { payload, transferables } = deconstructTransfer(resultValue);
+    const resultMessage = {
+        type: WorkerMessageType.result,
+        uid,
+        complete: completed ? true : undefined,
+        payload
+    };
+    Implementation.postMessageToMaster(resultMessage, transferables);
+}
+function postJobStartMessage(uid, resultType) {
+    const startMessage = {
+        type: WorkerMessageType.running,
+        uid,
+        resultType
+    };
+    Implementation.postMessageToMaster(startMessage);
+}
+function postUncaughtErrorMessage(error) {
+    try {
+        const errorMessage = {
+            type: WorkerMessageType.uncaughtError,
+            error: serialize(error)
+        };
+        Implementation.postMessageToMaster(errorMessage);
+    }
+    catch (subError) {
+        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);
+    }
+}
+function runFunction(jobUID, fn, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = yield 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
+ */
+function expose(exposed) {
+    if (!Implementation.isWorkerRuntime()) {
+        throw Error("expose() called in the master thread.");
+    }
+    if (exposeCalled) {
+        throw 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 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);
+        }
+    });
+}
+
+export { expose, isWorkerRuntime };

package/esm/worker_threads.mjs

@@ -0,0 +1,21 @@
+import { createRequire as __createRequire } from "module";
+import { fileURLToPath as __fileURLToPath } from "url";
+import { dirname as __pathDirname } from "path";
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+// Webpack hack
+let implementation;
+function selectImplementation() {
+    return typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__("worker_threads")
+        : eval("require")("worker_threads");
+}
+function getImplementation() {
+    if (!implementation) {
+        implementation = selectImplementation();
+    }
+    return implementation;
+}
+
+export { getImplementation as default };