threads - npm Package Compare versions

Comparing version 1.6.2 to 1.6.3-callbacks

dist-esm/index.js

@@ -1,5 +0,6 @@
-export { registerSerializer } from "./common";
+export { Callback } from "./common/callbacks";
+export { registerSerializer } from "./common/serialization";
 export * from "./master/index";
 export { expose } from "./worker/index";
-export { DefaultSerializer } from "./serializers";
-export { Transfer } from "./transferable";
+export { DefaultSerializer } from "./serializers/index";
+export { Transfer } from "./common/transferable";

dist-esm/master/implementation.node.js

@@ -154,3 +154,3 @@ /// <reference lib="dom" />
             this.onerror = (error) => this.emitter.emit("error", error);
-            this.onmessage = (message) => this.emitter.emit("message", message);
+            this.onmessage = (event) => this.emitter.emit("message", event);
         }
@@ -157,0 +157,0 @@ addEventListener(eventName, listener) {

dist-esm/master/index.js

 import { getWorkerImplementation, isWorkerRuntime } from "./implementation";
+export { Callback } from "../common/callbacks";
 export { Pool } from "./pool";
@@ -3,0 +4,0 @@ export { spawn } from "./spawn";

dist-esm/master/pool.js

@@ -220,6 +220,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
         }
-        const taskCompleted = () => this.taskCompletion(task.id);
-        let taskCompletionDotThen;
+        const taskID = this.nextTaskID++;
+        const taskCompletion = this.taskCompletion(taskID);
+        taskCompletion.catch((error) => {
+            // Prevent unhandled rejections here as we assume the user will use
+            // `pool.completed()`, `pool.settled()` or `task.catch()` to handle errors
+            this.debug(`Task #${taskID} errored:`, error);
+        });
         const task = {
-            id: this.nextTaskID++,
+            id: taskID,
             run: taskFunction,
@@ -235,9 +240,3 @@ cancel: () => {
             },
-            get then() {
-                if (!taskCompletionDotThen) {
-                    const promise = taskCompleted();
-                    taskCompletionDotThen = promise.then.bind(promise);
-                }
-                return taskCompletionDotThen;
-            }
+            then: taskCompletion.then.bind(taskCompletion)
         };
@@ -244,0 +243,0 @@ if (this.taskQueue.length >= maxQueuedJobs) {

dist-esm/master/spawn.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
 import { Observable } from "observable-fns";
-import { deserialize } from "../common";
-import { createPromiseWithResolver } from "../promise";
+import { createProxyFunction, createProxyModule, handleFunctionInvocations } from "../common/call-proxy";
+import { deserialize, getRegisteredSerializer } from "../common/serialization";
 import { $errors, $events, $terminate, $worker } from "../symbols";
 import { WorkerEventType } from "../types/master";
-import { createProxyFunction, createProxyModule } from "./invocation-proxy";
+import { createPromiseWithResolver } from "../util/promise";
 const debugMessages = DebugLogger("threads:master:messages");
@@ -50,3 +50,3 @@ const debugSpawn = DebugLogger("threads:master:spawn");
                 worker.removeEventListener("message", messageHandler);
-                reject(deserialize(event.data.error));
+                reject(deserialize(event.data.error, worker));
             }
@@ -125,8 +125,11 @@ });
         const events = createEventObservable(worker, termination);
+        const serializer = getRegisteredSerializer();
         if (exposed.type === "function") {
-            const proxy = createProxyFunction(worker);
+            const proxy = createProxyFunction(worker, serializer, 0, debugMessages);
+            handleFunctionInvocations(worker, serializer, debugMessages);
             return setPrivateThreadProps(proxy, worker, events, terminate);
         }
         else if (exposed.type === "module") {
-            const proxy = createProxyModule(worker, exposed.methods);
+            const proxy = createProxyModule(worker, serializer, exposed.methods, debugMessages);
+            handleFunctionInvocations(worker, serializer, debugMessages);
             return setPrivateThreadProps(proxy, worker, events, terminate);
@@ -133,0 +136,0 @@ }

dist-esm/symbols.js

@@ -0,1 +1,2 @@
+export const $callback = Symbol("thread.callback");
 export const $errors = Symbol("thread.errors");
@@ -2,0 +3,0 @@ export const $events = Symbol("thread.events");

dist-esm/types/messages.js

@@ -1,8 +0,9 @@
-/////////////////////////////
-// Messages sent by master:
-export var MasterMessageType;
-(function (MasterMessageType) {
-    MasterMessageType["cancel"] = "cancel";
-    MasterMessageType["run"] = "run";
-})(MasterMessageType || (MasterMessageType = {}));
+export var CommonMessageType;
+(function (CommonMessageType) {
+    CommonMessageType["cancel"] = "call:cancel";
+    CommonMessageType["error"] = "call:error";
+    CommonMessageType["invoke"] = "call:invoke";
+    CommonMessageType["result"] = "call:result";
+    CommonMessageType["running"] = "call:running";
+})(CommonMessageType || (CommonMessageType = {}));
 ////////////////////////////
@@ -12,7 +13,4 @@ // Messages sent by worker:
 (function (WorkerMessageType) {
-    WorkerMessageType["error"] = "error";
     WorkerMessageType["init"] = "init";
-    WorkerMessageType["result"] = "result";
-    WorkerMessageType["running"] = "running";
     WorkerMessageType["uncaughtError"] = "uncaughtError";
 })(WorkerMessageType || (WorkerMessageType = {}));

dist-esm/worker/implementation.browser.js

 /// <reference lib="dom" />
 // tslint:disable no-shadowed-variable
+import { multiplexEventTarget } from "../util/events";
 const isWorkerRuntime = function isWorkerRuntime() {
@@ -7,19 +8,18 @@ const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
 };
-const postMessageToMaster = function postMessageToMaster(data, transferList) {
+const postMessage = 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 {
+let muxedSelfEvents;
+const Implementation = {
+    addEventListener(event, handler) {
+        muxedSelfEvents = muxedSelfEvents || multiplexEventTarget(self);
+        return muxedSelfEvents.addEventListener(event, handler);
+    },
+    removeEventListener(event, handler) {
+        muxedSelfEvents = muxedSelfEvents || multiplexEventTarget(self);
+        return muxedSelfEvents.removeEventListener(event, handler);
+    },
     isWorkerRuntime,
-    postMessageToMaster,
-    subscribeToMasterMessages
+    postMessage
 };
+export default Implementation;

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

 /// <reference lib="dom" />
 // tslint:disable no-shadowed-variable
+import { multiplexEventTarget } from "../util/events";
 if (typeof self === "undefined") {
@@ -9,25 +10,8 @@ global.self = global;
 };
-const postMessageToMaster = function postMessageToMaster(data) {
+const postMessage = function postMessage(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) => {
-            messageHandlers.forEach(handler => handler(event.data));
-        }));
-        muxingHandlerSetUp = true;
-    }
-    messageHandlers.add(onMessage);
-    const unsubscribe = () => messageHandlers.delete(onMessage);
-    return unsubscribe;
-};
-export default {
-    isWorkerRuntime,
-    postMessageToMaster,
-    subscribeToMasterMessages
-};
+const Implementation = Object.assign(Object.assign({}, multiplexEventTarget(self)), { isWorkerRuntime,
+    postMessage });
+export default Implementation;

dist-esm/worker/implementation.worker_threads.js

@@ -11,19 +11,5 @@ import WorkerThreads from "../worker_threads";
 };
-const postMessageToMaster = function postMessageToMaster(data, transferList) {
+const postMessage = function postMessage(data, transferList) {
     assertMessagePort(WorkerThreads().parentPort).postMessage(data, transferList);
 };
-const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
-    const parentPort = WorkerThreads().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() {
@@ -33,7 +19,17 @@ // Will throw if `worker_threads` are not available
 }
-export default {
+const Implementation = {
+    addEventListener(event, listener) {
+        const port = assertMessagePort(WorkerThreads().parentPort);
+        return event === "message"
+            ? port.on(event, (data) => listener({ data }))
+            : port.on(event, listener);
+    },
+    removeEventListener(event, listener) {
+        const port = assertMessagePort(WorkerThreads().parentPort);
+        return port.off(event, listener);
+    },
     isWorkerRuntime,
-    postMessageToMaster,
-    subscribeToMasterMessages,
+    postMessage,
     testImplementation
 };
+export default Implementation;

dist-esm/worker/index.js

@@ -1,36 +0,14 @@
-var __awaiter = (this && this.__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());
-    });
-};
-import isSomeObservable from "is-observable";
-import { deserialize, serialize } from "../common";
-import { isTransferDescriptor } from "../transferable";
-import { MasterMessageType, WorkerMessageType } from "../types/messages";
+import DebugLogger from "debug";
+import { handleCallCancellations, handleFunctionInvocations } from "../common/call-proxy";
+import { Callback, SingleExposedCallback } from "../common/callbacks";
+import { getRegisteredSerializer, serialize } from "../common/serialization";
+import { WorkerMessageType } from "../types/messages";
 import Implementation from "./implementation";
-export { registerSerializer } from "../common";
-export { Transfer } from "../transferable";
+export { Callback } from "../common/callbacks";
+export { registerSerializer } from "../common/serialization";
+export { Transfer } from "../common/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 };
-}
+const debugIncomingMessages = DebugLogger("threads:worker:messages");
 function postFunctionInitMessage() {
@@ -43,5 +21,5 @@ const initMessage = {
     };
-    Implementation.postMessageToMaster(initMessage);
+    Implementation.postMessage(initMessage);
 }
-function postModuleInitMessage(methodNames) {
+function postModuleInitMessage(methods) {
     const initMessage = {
@@ -51,34 +29,7 @@ type: WorkerMessageType.init,
             type: "module",
-            methods: methodNames
+            methods
         }
     };
-    Implementation.postMessageToMaster(initMessage);
+    Implementation.postMessage(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) {
@@ -90,3 +41,3 @@ try {
         };
-        Implementation.postMessageToMaster(errorMessage);
+        Implementation.postMessage(errorMessage);
     }
@@ -100,34 +51,2 @@ catch (subError) {
 }
-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));
-            }
-        }
-    });
-}
 /**
@@ -149,17 +68,13 @@ * Expose a function or a module (an object whose values are functions)
     if (typeof exposed === "function") {
-        Implementation.subscribeToMasterMessages(messageData => {
-            if (isMasterJobRunMessage(messageData) && !messageData.method) {
-                runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
-            }
-        });
+        SingleExposedCallback(exposed);
+        handleFunctionInvocations(Implementation, getRegisteredSerializer(), debugIncomingMessages);
         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);
+        const methods = Object.keys(exposed).reduce((reduced, methodName) => {
+            const callback = Callback(exposed[methodName]);
+            return Object.assign(Object.assign({}, reduced), { [methodName]: callback.id });
+        }, {});
+        handleFunctionInvocations(Implementation, getRegisteredSerializer(), debugIncomingMessages);
+        postModuleInitMessage(methods);
     }
@@ -169,12 +84,3 @@ else {
     }
-    Implementation.subscribeToMasterMessages(messageData => {
-        if (isMasterJobCancelMessage(messageData)) {
-            const jobUID = messageData.uid;
-            const subscription = activeSubscriptions.get(jobUID);
-            if (subscription) {
-                subscription.unsubscribe();
-                activeSubscriptions.delete(jobUID);
-            }
-        }
-    });
+    handleCallCancellations(Implementation, debugIncomingMessages);
 }
@@ -181,0 +87,0 @@ if (typeof self !== "undefined" && typeof self.addEventListener === "function" && Implementation.isWorkerRuntime()) {

dist/index.d.ts

@@ -1,5 +0,6 @@
-export { registerSerializer } from "./common";
+export { Callback } from "./common/callbacks";
+export { registerSerializer } from "./common/serialization";
 export * from "./master/index";
 export { expose } from "./worker/index";
-export { DefaultSerializer, JsonSerializable, Serializer, SerializerImplementation } from "./serializers";
-export { Transfer, TransferDescriptor } from "./transferable";
+export { DefaultSerializer, JsonSerializable, Serializer, SerializerImplementation } from "./serializers/index";
+export { Transfer, TransferDescriptor } from "./common/transferable";

dist/index.js

@@ -13,10 +13,12 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("./common");
-Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_1.registerSerializer; } });
+var callbacks_1 = require("./common/callbacks");
+Object.defineProperty(exports, "Callback", { enumerable: true, get: function () { return callbacks_1.Callback; } });
+var serialization_1 = require("./common/serialization");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return serialization_1.registerSerializer; } });
 __exportStar(require("./master/index"), exports);
 var index_1 = require("./worker/index");
 Object.defineProperty(exports, "expose", { enumerable: true, get: function () { return index_1.expose; } });
-var serializers_1 = require("./serializers");
-Object.defineProperty(exports, "DefaultSerializer", { enumerable: true, get: function () { return serializers_1.DefaultSerializer; } });
-var transferable_1 = require("./transferable");
+var index_2 = require("./serializers/index");
+Object.defineProperty(exports, "DefaultSerializer", { enumerable: true, get: function () { return index_2.DefaultSerializer; } });
+var transferable_1 = require("./common/transferable");
 Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_1.Transfer; } });

dist/master/implementation.node.js

@@ -179,3 +179,3 @@ "use strict";
             this.onerror = (error) => this.emitter.emit("error", error);
-            this.onmessage = (message) => this.emitter.emit("message", message);
+            this.onmessage = (event) => this.emitter.emit("message", event);
         }
@@ -182,0 +182,0 @@ addEventListener(eventName, listener) {

dist/master/index.d.ts

 import type { BlobWorker as BlobWorkerClass } from "../types/master";
 import { Worker as WorkerType } from "../types/master";
 import { isWorkerRuntime } from "./implementation";
+export { Callback } from "../common/callbacks";
 export { FunctionThread, ModuleThread } from "../types/master";
@@ -5,0 +6,0 @@ export { Pool } from "./pool";

dist/master/index.js

@@ -6,2 +6,4 @@ "use strict";
 Object.defineProperty(exports, "isWorkerRuntime", { enumerable: true, get: function () { return implementation_1.isWorkerRuntime; } });
+var callbacks_1 = require("../common/callbacks");
+Object.defineProperty(exports, "Callback", { enumerable: true, get: function () { return callbacks_1.Callback; } });
 var pool_1 = require("./pool");
@@ -8,0 +10,0 @@ Object.defineProperty(exports, "Pool", { enumerable: true, get: function () { return pool_1.Pool; } });

dist/master/pool.js

@@ -227,6 +227,11 @@ "use strict";
         }
-        const taskCompleted = () => this.taskCompletion(task.id);
-        let taskCompletionDotThen;
+        const taskID = this.nextTaskID++;
+        const taskCompletion = this.taskCompletion(taskID);
+        taskCompletion.catch((error) => {
+            // Prevent unhandled rejections here as we assume the user will use
+            // `pool.completed()`, `pool.settled()` or `task.catch()` to handle errors
+            this.debug(`Task #${taskID} errored:`, error);
+        });
         const task = {
-            id: this.nextTaskID++,
+            id: taskID,
             run: taskFunction,
@@ -242,9 +247,3 @@ cancel: () => {
             },
-            get then() {
-                if (!taskCompletionDotThen) {
-                    const promise = taskCompleted();
-                    taskCompletionDotThen = promise.then.bind(promise);
-                }
-                return taskCompletionDotThen;
-            }
+            then: taskCompletion.then.bind(taskCompletion)
         };
@@ -251,0 +250,0 @@ if (this.taskQueue.length >= maxQueuedJobs) {

dist/master/spawn.js

@@ -18,7 +18,7 @@ "use strict";
 const observable_fns_1 = require("observable-fns");
-const common_1 = require("../common");
-const promise_1 = require("../promise");
+const call_proxy_1 = require("../common/call-proxy");
+const serialization_1 = require("../common/serialization");
 const symbols_1 = require("../symbols");
 const master_1 = require("../types/master");
-const invocation_proxy_1 = require("./invocation-proxy");
+const promise_1 = require("../util/promise");
 const debugMessages = debug_1.default("threads:master:messages");
@@ -56,3 +56,3 @@ const debugSpawn = debug_1.default("threads:master:spawn");
                 worker.removeEventListener("message", messageHandler);
-                reject(common_1.deserialize(event.data.error));
+                reject(serialization_1.deserialize(event.data.error, worker));
             }
@@ -131,8 +131,11 @@ });
         const events = createEventObservable(worker, termination);
+        const serializer = serialization_1.getRegisteredSerializer();
         if (exposed.type === "function") {
-            const proxy = invocation_proxy_1.createProxyFunction(worker);
+            const proxy = call_proxy_1.createProxyFunction(worker, serializer, 0, debugMessages);
+            call_proxy_1.handleFunctionInvocations(worker, serializer, debugMessages);
             return setPrivateThreadProps(proxy, worker, events, terminate);
         }
         else if (exposed.type === "module") {
-            const proxy = invocation_proxy_1.createProxyModule(worker, exposed.methods);
+            const proxy = call_proxy_1.createProxyModule(worker, serializer, exposed.methods, debugMessages);
+            call_proxy_1.handleFunctionInvocations(worker, serializer, debugMessages);
             return setPrivateThreadProps(proxy, worker, events, terminate);
@@ -139,0 +142,0 @@ }

dist/symbols.d.ts

@@ -0,1 +1,2 @@
+export declare const $callback: unique symbol;
 export declare const $errors: unique symbol;
@@ -2,0 +3,0 @@ export declare const $events: unique symbol;

dist/symbols.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = void 0;
+exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = exports.$callback = void 0;
+exports.$callback = Symbol("thread.callback");
 exports.$errors = Symbol("thread.errors");
@@ -5,0 +6,0 @@ exports.$events = Symbol("thread.events");

dist/types/master.d.ts

 /// <reference lib="dom" />
 import { Observable } from "observable-fns";
-import { ObservablePromise } from "../observable-promise";
+import { ObservablePromise } from "../common/observable-promise";
 import { $errors, $events, $terminate, $worker } from "../symbols";
+import { MessageRelay, TransferList } from "./common";
 interface ObservableLikeSubscription {
@@ -17,6 +18,7 @@ unsubscribe(): any;
 export declare type StripAsync<Type> = Type extends Promise<infer PromiseBaseType> ? PromiseBaseType : Type extends ObservableLike<infer ObservableBaseType> ? ObservableBaseType : Type;
+export declare type AsyncifyIterator<Type> = Type extends Iterator<infer T> ? AsyncIterator<T> & AsyncIterable<T> : Type extends AsyncIterator<infer T2> ? AsyncIterator<T2> & AsyncIterable<T2> : Type;
 export declare type ModuleMethods = {
     [methodName: string]: (...args: any) => any;
 };
-export declare type ProxyableFunction<Args extends any[], ReturnType> = Args extends [] ? () => ObservablePromise<StripAsync<ReturnType>> : (...args: Args) => ObservablePromise<StripAsync<ReturnType>>;
+export declare type ProxyableFunction<Args extends any[], ReturnType> = Args extends [] ? () => ObservablePromise<AsyncifyIterator<StripAsync<ReturnType>>> : (...args: Args) => ObservablePromise<AsyncifyIterator<StripAsync<ReturnType>>>;
 export declare type ModuleProxy<Methods extends ModuleMethods> = {
@@ -40,6 +42,5 @@ [method in keyof Methods]: ProxyableFunction<Parameters<Methods[method]>, ReturnType<Methods[method]>>;
 export declare type Thread = AnyFunctionThread | AnyModuleThread;
-export declare type TransferList = Transferable[];
 /** Worker instance. Either a web worker or a node.js Worker provided by `worker_threads` or `tiny-worker`. */
-export interface Worker extends EventTarget {
-    postMessage(value: any, transferList?: TransferList): void;
+export interface Worker extends MessageRelay {
+    removeEventListener(event: string, listener: EventListener): any;
     terminate(callback?: (error?: Error, exitCode?: number) => void): void;
@@ -59,2 +60,3 @@ }
     };
+    timeout?: number;
 }
@@ -64,3 +66,5 @@ /** Worker implementation. Either web worker or a node.js Worker class. */
     constructor(path: string, options?: ThreadsWorkerOptions);
+    addEventListener: MessageRelay["addEventListener"];
     postMessage(value: any, transferList?: TransferList): void;
+    removeEventListener(event: string, listener: EventListener): any;
     terminate(): void;
@@ -67,0 +71,0 @@ }

dist/types/messages.d.ts

@@ -1,27 +0,39 @@
-export interface SerializedError {
-    __error_marker: "$$error";
-    message: string;
-    name: string;
-    stack?: string;
+import { SerializedError } from "./serializers";
+export declare enum CommonMessageType {
+    cancel = "call:cancel",
+    error = "call:error",
+    invoke = "call:invoke",
+    result = "call:result",
+    running = "call:running"
 }
-export declare enum MasterMessageType {
-    cancel = "cancel",
-    run = "run"
-}
-export declare type MasterJobCancelMessage = {
-    type: MasterMessageType.cancel;
+export declare type CallCancelMessage = {
+    type: CommonMessageType.cancel;
     uid: number;
 };
-export declare type MasterJobRunMessage = {
-    type: MasterMessageType.run;
+export declare type CallErrorMessage = {
+    type: CommonMessageType.error;
     uid: number;
-    method?: string;
+    error: SerializedError;
+};
+export declare type CallInvocationMessage = {
+    type: CommonMessageType.invoke;
+    /** Function ID */
+    fid: number;
+    /** Unique call ID */
+    uid: number;
     args: any[];
 };
-export declare type MasterSentMessage = MasterJobCancelMessage | MasterJobRunMessage;
+export declare type CallResultMessage = {
+    type: CommonMessageType.result;
+    uid: number;
+    complete?: true;
+    payload?: any;
+};
+export declare type CallRunningMessage = {
+    type: CommonMessageType.running;
+    uid: number;
+    resultType: "observable" | "promise";
+};
 export declare enum WorkerMessageType {
-    error = "error",
     init = "init",
-    result = "result",
-    running = "running",
     uncaughtError = "uncaughtError"
@@ -43,21 +55,4 @@ }
         type: "module";
-        methods: string[];
+        methods: Record<string, number>;
     };
 };
-export declare type WorkerJobErrorMessage = {
-    type: WorkerMessageType.error;
-    uid: number;
-    error: SerializedError;
-};
-export declare type WorkerJobResultMessage = {
-    type: WorkerMessageType.result;
-    uid: number;
-    complete?: true;
-    payload?: any;
-};
-export declare type WorkerJobStartMessage = {
-    type: WorkerMessageType.running;
-    uid: number;
-    resultType: "observable" | "promise";
-};
-export declare type WorkerSentMessage = WorkerInitMessage | WorkerJobErrorMessage | WorkerJobResultMessage | WorkerJobStartMessage | WorkerUncaughtErrorMessage;

dist/types/messages.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerMessageType = exports.MasterMessageType = void 0;
-/////////////////////////////
-// Messages sent by master:
-var MasterMessageType;
-(function (MasterMessageType) {
-    MasterMessageType["cancel"] = "cancel";
-    MasterMessageType["run"] = "run";
-})(MasterMessageType = exports.MasterMessageType || (exports.MasterMessageType = {}));
+exports.WorkerMessageType = exports.CommonMessageType = void 0;
+var CommonMessageType;
+(function (CommonMessageType) {
+    CommonMessageType["cancel"] = "call:cancel";
+    CommonMessageType["error"] = "call:error";
+    CommonMessageType["invoke"] = "call:invoke";
+    CommonMessageType["result"] = "call:result";
+    CommonMessageType["running"] = "call:running";
+})(CommonMessageType = exports.CommonMessageType || (exports.CommonMessageType = {}));
 ////////////////////////////
@@ -15,7 +16,4 @@ // Messages sent by worker:
 (function (WorkerMessageType) {
-    WorkerMessageType["error"] = "error";
     WorkerMessageType["init"] = "init";
-    WorkerMessageType["result"] = "result";
-    WorkerMessageType["running"] = "running";
     WorkerMessageType["uncaughtError"] = "uncaughtError";
 })(WorkerMessageType = exports.WorkerMessageType || (exports.WorkerMessageType = {}));

dist/types/worker.d.ts

@@ -1,6 +0,4 @@
-declare type UnsubscribeFn = () => void;
-export interface AbstractedWorkerAPI {
+import { MessageRelay } from "./common";
+export interface AbstractedWorkerAPI extends MessageRelay {
     isWorkerRuntime(): boolean;
-    postMessageToMaster(message: any, transferList?: Transferable[]): void;
-    subscribeToMasterMessages(onMessage: (data: any) => void): UnsubscribeFn;
 }
@@ -11,2 +9,1 @@ export declare type WorkerFunction = ((...args: any[]) => any) | (() => any);
 };
-export {};

dist/worker/implementation.browser.d.ts

 /// <reference lib="dom" />
-declare const _default: {
-    isWorkerRuntime: () => boolean;
-    postMessageToMaster: (message: any, transferList?: Transferable[] | undefined) => void;
-    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
-};
-export default _default;
+import { AbstractedWorkerAPI } from "../types/worker";
+declare const Implementation: AbstractedWorkerAPI;
+export default Implementation;

dist/worker/implementation.browser.js

@@ -5,2 +5,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("../util/events");
 const isWorkerRuntime = function isWorkerRuntime() {
@@ -10,19 +11,18 @@ const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
 };
-const postMessageToMaster = function postMessageToMaster(data, transferList) {
+const postMessage = 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;
-};
-exports.default = {
+let muxedSelfEvents;
+const Implementation = {
+    addEventListener(event, handler) {
+        muxedSelfEvents = muxedSelfEvents || events_1.multiplexEventTarget(self);
+        return muxedSelfEvents.addEventListener(event, handler);
+    },
+    removeEventListener(event, handler) {
+        muxedSelfEvents = muxedSelfEvents || events_1.multiplexEventTarget(self);
+        return muxedSelfEvents.removeEventListener(event, handler);
+    },
     isWorkerRuntime,
-    postMessageToMaster,
-    subscribeToMasterMessages
+    postMessage
 };
+exports.default = Implementation;

dist/worker/implementation.tiny-worker.d.ts

 /// <reference lib="dom" />
-declare const _default: {
-    isWorkerRuntime: () => boolean;
-    postMessageToMaster: (message: any, transferList?: Transferable[] | undefined) => void;
-    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
-};
-export default _default;
+import { AbstractedWorkerAPI } from "../types/worker";
+declare const Implementation: AbstractedWorkerAPI;
+export default Implementation;

dist/worker/implementation.tiny-worker.js

@@ -5,2 +5,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("../util/events");
 if (typeof self === "undefined") {
@@ -12,25 +13,8 @@ global.self = global;
 };
-const postMessageToMaster = function postMessageToMaster(data) {
+const postMessage = function postMessage(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) => {
-            messageHandlers.forEach(handler => handler(event.data));
-        }));
-        muxingHandlerSetUp = true;
-    }
-    messageHandlers.add(onMessage);
-    const unsubscribe = () => messageHandlers.delete(onMessage);
-    return unsubscribe;
-};
-exports.default = {
-    isWorkerRuntime,
-    postMessageToMaster,
-    subscribeToMasterMessages
-};
+const Implementation = Object.assign(Object.assign({}, events_1.multiplexEventTarget(self)), { isWorkerRuntime,
+    postMessage });
+exports.default = Implementation;

dist/worker/implementation.worker_threads.d.ts

@@ -0,8 +1,6 @@
+import { AbstractedWorkerAPI } from "../types/worker";
 declare function testImplementation(): void;
-declare const _default: {
-    isWorkerRuntime: () => boolean;
-    postMessageToMaster: (message: any, transferList?: Transferable[] | undefined) => void;
-    subscribeToMasterMessages: (onMessage: (data: any) => void) => () => void;
+declare const Implementation: AbstractedWorkerAPI & {
     testImplementation: typeof testImplementation;
 };
-export default _default;
+export default Implementation;

dist/worker/implementation.worker_threads.js

@@ -16,19 +16,5 @@ "use strict";
 };
-const postMessageToMaster = function postMessageToMaster(data, transferList) {
+const postMessage = function postMessage(data, transferList) {
     assertMessagePort(worker_threads_1.default().parentPort).postMessage(data, transferList);
 };
-const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
-    const parentPort = worker_threads_1.default().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() {
@@ -38,7 +24,17 @@ // Will throw if `worker_threads` are not available
 }
-exports.default = {
+const Implementation = {
+    addEventListener(event, listener) {
+        const port = assertMessagePort(worker_threads_1.default().parentPort);
+        return event === "message"
+            ? port.on(event, (data) => listener({ data }))
+            : port.on(event, listener);
+    },
+    removeEventListener(event, listener) {
+        const port = assertMessagePort(worker_threads_1.default().parentPort);
+        return port.off(event, listener);
+    },
     isWorkerRuntime,
-    postMessageToMaster,
-    subscribeToMasterMessages,
+    postMessage,
     testImplementation
 };
+exports.default = Implementation;

dist/worker/index.d.ts

 import { WorkerFunction, WorkerModule } from "../types/worker";
-export { registerSerializer } from "../common";
-export { Transfer } from "../transferable";
+export { Callback } from "../common/callbacks";
+export { registerSerializer } from "../common/serialization";
+export { Transfer } from "../common/transferable";
 /** Returns `true` if this code is currently running in a worker. */
@@ -5,0 +6,0 @@ export declare const isWorkerRuntime: () => boolean;

dist/worker/index.js

 "use strict";
-var __awaiter = (this && this.__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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -16,30 +7,18 @@ return (mod && mod.__esModule) ? mod : { "default": mod };
 exports.expose = exports.isWorkerRuntime = void 0;
-const is_observable_1 = __importDefault(require("is-observable"));
-const common_1 = require("../common");
-const transferable_1 = require("../transferable");
+const debug_1 = __importDefault(require("debug"));
+const call_proxy_1 = require("../common/call-proxy");
+const callbacks_1 = require("../common/callbacks");
+const serialization_1 = require("../common/serialization");
 const messages_1 = require("../types/messages");
 const implementation_1 = __importDefault(require("./implementation"));
-var common_2 = require("../common");
-Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_2.registerSerializer; } });
-var transferable_2 = require("../transferable");
-Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_2.Transfer; } });
+var callbacks_2 = require("../common/callbacks");
+Object.defineProperty(exports, "Callback", { enumerable: true, get: function () { return callbacks_2.Callback; } });
+var serialization_2 = require("../common/serialization");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return serialization_2.registerSerializer; } });
+var transferable_1 = require("../common/transferable");
+Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_1.Transfer; } });
 /** Returns `true` if this code is currently running in a worker. */
 exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
 let exposeCalled = false;
-const activeSubscriptions = new Map();
-const isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
-const isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.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) => is_observable_1.default(thing) || isZenObservable(thing);
-function isZenObservable(thing) {
-    return thing && typeof thing === "object" && typeof thing.subscribe === "function";
-}
-function deconstructTransfer(thing) {
-    return transferable_1.isTransferDescriptor(thing)
-        ? { payload: thing.send, transferables: thing.transferables }
-        : { payload: thing, transferables: undefined };
-}
+const debugIncomingMessages = debug_1.default("threads:worker:messages");
 function postFunctionInitMessage() {
@@ -52,5 +31,5 @@ const initMessage = {
     };
-    implementation_1.default.postMessageToMaster(initMessage);
+    implementation_1.default.postMessage(initMessage);
 }
-function postModuleInitMessage(methodNames) {
+function postModuleInitMessage(methods) {
     const initMessage = {
@@ -60,34 +39,7 @@ type: messages_1.WorkerMessageType.init,
             type: "module",
-            methods: methodNames
+            methods
         }
     };
-    implementation_1.default.postMessageToMaster(initMessage);
+    implementation_1.default.postMessage(initMessage);
 }
-function postJobErrorMessage(uid, rawError) {
-    const { payload: error, transferables } = deconstructTransfer(rawError);
-    const errorMessage = {
-        type: messages_1.WorkerMessageType.error,
-        uid,
-        error: common_1.serialize(error)
-    };
-    implementation_1.default.postMessageToMaster(errorMessage, transferables);
-}
-function postJobResultMessage(uid, completed, resultValue) {
-    const { payload, transferables } = deconstructTransfer(resultValue);
-    const resultMessage = {
-        type: messages_1.WorkerMessageType.result,
-        uid,
-        complete: completed ? true : undefined,
-        payload
-    };
-    implementation_1.default.postMessageToMaster(resultMessage, transferables);
-}
-function postJobStartMessage(uid, resultType) {
-    const startMessage = {
-        type: messages_1.WorkerMessageType.running,
-        uid,
-        resultType
-    };
-    implementation_1.default.postMessageToMaster(startMessage);
-}
 function postUncaughtErrorMessage(error) {
@@ -97,5 +49,5 @@ try {
             type: messages_1.WorkerMessageType.uncaughtError,
-            error: common_1.serialize(error)
+            error: serialization_1.serialize(error)
         };
-        implementation_1.default.postMessageToMaster(errorMessage);
+        implementation_1.default.postMessage(errorMessage);
     }
@@ -109,34 +61,2 @@ catch (subError) {
 }
-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, common_1.serialize(value)), error => {
-                postJobErrorMessage(jobUID, common_1.serialize(error));
-                activeSubscriptions.delete(jobUID);
-            }, () => {
-                postJobResultMessage(jobUID, true);
-                activeSubscriptions.delete(jobUID);
-            });
-            activeSubscriptions.set(jobUID, subscription);
-        }
-        else {
-            try {
-                const result = yield syncResult;
-                postJobResultMessage(jobUID, true, common_1.serialize(result));
-            }
-            catch (error) {
-                postJobErrorMessage(jobUID, common_1.serialize(error));
-            }
-        }
-    });
-}
 /**
@@ -158,17 +78,13 @@ * Expose a function or a module (an object whose values are functions)
     if (typeof exposed === "function") {
-        implementation_1.default.subscribeToMasterMessages(messageData => {
-            if (isMasterJobRunMessage(messageData) && !messageData.method) {
-                runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
-            }
-        });
+        callbacks_1.SingleExposedCallback(exposed);
+        call_proxy_1.handleFunctionInvocations(implementation_1.default, serialization_1.getRegisteredSerializer(), debugIncomingMessages);
         postFunctionInitMessage();
     }
     else if (typeof exposed === "object" && exposed) {
-        implementation_1.default.subscribeToMasterMessages(messageData => {
-            if (isMasterJobRunMessage(messageData) && messageData.method) {
-                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
-            }
-        });
-        const methodNames = Object.keys(exposed).filter(key => typeof exposed[key] === "function");
-        postModuleInitMessage(methodNames);
+        const methods = Object.keys(exposed).reduce((reduced, methodName) => {
+            const callback = callbacks_1.Callback(exposed[methodName]);
+            return Object.assign(Object.assign({}, reduced), { [methodName]: callback.id });
+        }, {});
+        call_proxy_1.handleFunctionInvocations(implementation_1.default, serialization_1.getRegisteredSerializer(), debugIncomingMessages);
+        postModuleInitMessage(methods);
     }
@@ -178,12 +94,3 @@ else {
     }
-    implementation_1.default.subscribeToMasterMessages(messageData => {
-        if (isMasterJobCancelMessage(messageData)) {
-            const jobUID = messageData.uid;
-            const subscription = activeSubscriptions.get(jobUID);
-            if (subscription) {
-                subscription.unsubscribe();
-                activeSubscriptions.delete(jobUID);
-            }
-        }
-    });
+    call_proxy_1.handleCallCancellations(implementation_1.default, debugIncomingMessages);
 }
@@ -190,0 +97,0 @@ exports.expose = expose;

observable.d.ts

@@ -1,1 +0,1 @@
-export * from "./dist/observable"
+export * from "./dist/util/observable"

observable.js

@@ -1,1 +0,1 @@
-module.exports = require("./dist/observable")
+module.exports = require("./dist/util/observable")

package.json

 {
   "name": "threads",
-  "version": "1.6.2",
+  "version": "1.6.3-callbacks",
   "description": "Web workers & worker threads as simple as a function call",
@@ -91,3 +91,3 @@ "main": "dist/index.js",
     "rollup-plugin-node-resolve": "^5.1.0",
-    "threads-plugin": "^1.2.0",
+    "threads-plugin": "^1.3.2",
     "tiny-worker": "^2.2.0",
@@ -94,0 +94,0 @@ "ts-loader": "^6.0.1",

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Fixed alerts

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

197937

increased by12.83%

Number of package files

126

increased by20%

Lines of code

4410

increased by11.25%

Number of low supply chain risk alerts

6

decreased by-25%

Worsened metrics

Number of low quality alerts

1

increased byInfinity%

No dependency changes