promise-worker-bi 6.0.1 → 6.0.3

package/README.md

@@ -85,7 +85,7 @@ The registered handler can return either a Promise or a normal value:
 
 ```js
 promiseWorker.register(async () => {
-	"much async, very promise";
+	return "much async, very promise";
 });
 ```
 
@@ -126,6 +126,8 @@ promiseWorker.addEventListener("error", (errorError) => {
 
 That will work if `worker` is a Web Worker or a Shared Worker, but there is one important difference. For a Shared Worker, it will only fire in the first host, to prevent duplicate errors from reaching an error log (assuming you're logging these errors somewhere).
 
+This also includes unhandled promise rejections inside the worker, which browsers otherwise only report in the worker's own console.
+
 #### Source maps
 
 If you use a source map for your worker script, this will not be reflected in the stack traces from promise-worker-bi (either in `promiseWorker.registerError` in response to `promiseWorker.postMessage`). However, you can still use your source map to translate the file/line/column numbers. Clever third-party error reporting services like [Bugsnag](https://www.bugsnag.com/) do this automatically!
@@ -287,7 +289,7 @@ Create a new instance of `PWBHost`, using the given worker.
 
 #### `promiseWorker.addEventListener("error", (event: ErrorEvent) => void)`
 
-When an error in your web/shared worker process occurs that is _not_ directly in response to a `promiseWorker.postMessage` call, you can see it by listening to the "error" event here.
+When an error in your web/shared worker process occurs that is _not_ directly in response to a `promiseWorker.postMessage` call, you can see it by listening to the "error" event here. This includes both uncaught errors and unhandled promise rejections.
 
 `promiseWorker` is EventTarget so you can use `addEventListener`, `removeEventListener`, and all their normal options.
 
@@ -309,7 +311,9 @@ Create a new instance of `PWBWorker`.
 
 Register a message handler wherever you will be receiving messages: in the worker, in the browser, or both. Your handler consumes a message and returns a promise or value.
 
-The `hostID` parameter is only defined inside a shared worker, in which case it is a unique number identifying the host that the message came from.
+If a message arrives and no handler has been registered, the sender's `postMessage` promise rejects with a "No handler registered" error.
+
+The `hostID` parameter is only meaningful inside a shared worker, in which case it is a unique number identifying the host that the message came from.
 
 The return value of the callback function (shown above as `unknown`) must resolve to something [structured cloneable](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
 

package/dist/index.d.ts

@@ -18,7 +18,7 @@ type QueryCallback = (a: unknown, b: number | undefined) => unknown;
 type EventMap = Record<string, Event>;
 declare abstract class PWBBase<Events extends EventMap> extends EventTarget {
   protected _callbacks: Map<number, (a: Error | null, b: unknown) => void>;
-  protected _queryCallback: QueryCallback;
+  protected _queryCallback: QueryCallback | undefined;
   constructor();
   addEventListener<K extends keyof Events>(type: K, listener: ((event: Events[K]) => void) | {
     handleEvent(object: Events[K]): void;
@@ -45,19 +45,20 @@ export declare class PWBHost extends PWBBase<HostEvents> {
   private _worker;
   constructor(worker: SharedWorker | Worker);
   protected _postMessage(obj: QueryMessage | ResponseMessage | HostLockMessage, _hostID?: unknown, transfer?: Transferable[] | undefined): void;
-  postMessage(userMessage: unknown, _hostID?: undefined, transfer?: Transferable[] | undefined): Promise<any>;
+  postMessage(userMessage: unknown, _hostID?: undefined, transfer?: Transferable[] | undefined): Promise<unknown>;
   private handleWorkerLock;
   private _onMessage;
 }
 //#endregion
 //#region src/PWBWorker.d.ts
-type WorkerEvents = Record<string, Event>;
+type WorkerEvents = Record<never, never>;
 export declare class PWBWorker extends PWBBase<WorkerEvents> {
   private _hosts;
   private _maxHostID;
   private _sharedWorker;
   private _workerLockAcquired;
   constructor();
+  private _postWorkerError;
   protected _postMessage(message: QueryMessage | ResponseMessage | HostIdMessage | WorkerLockMessage | WorkerErrorMessage, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): void;
   postMessage(userMessage: unknown, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): Promise<unknown>;
   private _onMessage;

package/dist/index.js

@@ -1,5 +1,8 @@
+const isDOMException = (value) => {
+	return typeof DOMException !== "undefined" && value instanceof DOMException;
+};
 const isError = (error) => {
-	if (Error.isError) return Error.isError(error);
+	if (Error.isError) return Error.isError(error) || isDOMException(error);
 	return true;
 };
 const parseMessage = (message) => {
@@ -42,6 +45,17 @@ const logError = (err) => {
 	console.error("Error in worker:");
 	console.error(err);
 };
+const toError = (value) => {
+	if (Error.isError ? Error.isError(value) || isDOMException(value) : value instanceof Error) return value;
+	let message;
+	if (typeof value === "string") message = value;
+	else try {
+		message = JSON.stringify(value) ?? String(value);
+	} catch {
+		message = String(value);
+	}
+	return new Error(message);
+};
 const isSharedWorker = (worker) => {
 	return worker.port !== void 0;
 };
@@ -51,7 +65,6 @@ var PWBBase = class extends EventTarget {
 	constructor() {
 		super();
 		this._callbacks = /* @__PURE__ */ new Map();
-		this._queryCallback = () => {};
 		this._onMessage = this._onMessage.bind(this);
 	}
 	addEventListener(type, listener, options) {
@@ -91,16 +104,20 @@ var PWBBase = class extends EventTarget {
 		const messageID = message[1];
 		const query = message[2];
 		const hostID = message[3];
+		if (this._queryCallback === void 0) {
+			this._postResponse(messageID, /* @__PURE__ */ new Error("No handler registered to receive this message"), void 0, hostID);
+			return;
+		}
 		try {
 			const result = this._queryCallback(query, hostID);
 			if (!isPromise(result)) this._postResponse(messageID, null, result, hostID);
 			else result.then((finalResult) => {
 				this._postResponse(messageID, null, finalResult, hostID);
 			}, (finalError) => {
-				this._postResponse(messageID, finalError, void 0, hostID);
+				this._postResponse(messageID, toError(finalError), void 0, hostID);
 			});
 		} catch (err) {
-			this._postResponse(messageID, err);
+			this._postResponse(messageID, toError(err), void 0, hostID);
 		}
 	}
 	_onMessageCommon(e) {
@@ -221,8 +238,7 @@ var PWBWorker = class extends PWBBase {
 		});
 		if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
 			this._sharedWorker = true;
-			const _self = self;
-			_self.addEventListener("connect", (e) => {
+			self.addEventListener("connect", (e) => {
 				const port = e.ports[0];
 				port.addEventListener("message", (e2) => this._onMessage(e2));
 				port.start();
@@ -238,23 +254,24 @@ var PWBWorker = class extends PWBBase {
 				else message = [2, hostID];
 				this._postMessage(message, hostID);
 			});
-			_self.addEventListener("error", (e) => {
-				logError(e.error);
-				e.preventDefault();
-				const hostID = this._hosts.keys().next().value;
-				if (hostID !== void 0) this._postMessage([5, e.error], hostID);
-			});
 		} else {
 			this._sharedWorker = false;
-			const _self = self;
-			_self.addEventListener("message", this._onMessage);
+			self.addEventListener("message", this._onMessage);
 			this._postMessage([2, 0], 0);
-			_self.addEventListener("error", (e) => {
-				logError(e.error);
-				e.preventDefault();
-				this._postMessage([5, e.error]);
-			});
 		}
+		self.addEventListener("error", (e) => {
+			logError(e.error);
+			e.preventDefault();
+			this._postWorkerError(e.error ?? e.message);
+		});
+		self.addEventListener("unhandledrejection", (e) => {
+			this._postWorkerError(e.reason);
+		});
+	}
+	_postWorkerError(value) {
+		const hostID = this._sharedWorker ? this._hosts.keys().next().value : void 0;
+		if (this._sharedWorker && hostID === void 0) return;
+		this._postMessage([5, toError(value)], hostID);
 	}
 	_postMessage(message, targetHostID, transfer) {
 		if (this._sharedWorker) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "promise-worker-bi",
-	"version": "6.0.1",
+	"version": "6.0.3",
 	"description": "Promise-based messaging for Web Workers and Shared Workers",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",