promise-worker-bi 6.0.0-beta.0 → 6.0.0

package/README.md

@@ -119,8 +119,8 @@ For a Web Worker, we could just use [the normal `error` event](https://developer
 Therefore, promise-worker-bi includes a unified API that works in Web Workers and Shared Workers. Include some code like this in your host:
 
 ```js
-promiseWorker.registerError((error) => {
-	console.log("Error inside worker!", err);
+promiseWorker.addEventListener("error", (errorError) => {
+	console.log("Error inside worker!", errorError.error);
 });
 ```
 
@@ -140,7 +140,7 @@ const response1 = await promiseWorker.postMessage({
 });
 
 const response2 = await promiseWorker.postMessage({
-	type: "en",
+	type: "fr",
 });
 ```
 
@@ -285,13 +285,17 @@ Create a new instance of `PWBHost`, using the given worker.
 
 - `worker` - the `Worker`, `SharedWorker` or [PseudoWorker](https://github.com/nolanlawson/pseudo-worker) to use.
 
-#### `promiseWorker.registerError((error: Error) => void)`
+#### `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.
+
+`promiseWorker` is EventTarget so you can use `addEventListener`, `removeEventListener`, and all their normal options.
 
-This should only be called in the browser, not in a worker.
+#### `promiseWorker.addEventListener("close", (event: Event) => void)`
 
-When an error in your web/shared worker process occurs that is _not_ directly in response to a `promiseWorker.postMessage` call, it will be sent to the callback you provide here to `promiseWorker.registerError`.
+There is no built-in API to listen for when a web/shared worker closes, which can happen in various situations such as the OS killing it to free up memory. promise-worker-bi includes a "close" event you can use for this purpose.
 
-Although [normally stack traces are not sent from the worker to the main thread](https://github.com/mknichel/javascript-errors/blob/master/README.md#dedicated-workers), promise-worker-bi magically works around this problem so you will see a stack trace in `error`.
+`promiseWorker` is EventTarget so you can use `addEventListener`, `removeEventListener`, and all their normal options.
 
 ### Worker bundle
 
@@ -301,17 +305,17 @@ Create a new instance of `PWBWorker`.
 
 ### Both bundles
 
-#### `promiseWorker.register((message: any, hostID?: number) => any)`
+#### `promiseWorker.register((message: unknown, hostID?: number) => unknown)`
 
 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.
 
-The return value of the callback function (shown above as `any`) must resolve to something [structured cloneable](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
+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).
 
-If you want to [transfer an object](https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects) in the return value of the callback, then the return type should be `{ message: any, _PWB_TRANSFER: Transferable[] }` rather than just `any`.
+If you want to [transfer an object](https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects) in the return value of the callback, then the return type should be `{ message: unknown, _PWB_TRANSFER: Transferable[] }` rather than just `unknown`.
 
-#### `promiseWorker.postMessage(message: any, hostID?: number, transfer?: Transferable[]): Promise<any>`
+#### `promiseWorker.postMessage(message: unknown, hostID?: number, transfer?: Transferable[]): Promise<unknown>`
 
 Send a message to the browser or worker and return a Promise. `message` 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

@@ -1,57 +1,64 @@
-//#region src/fakeError.d.ts
-type FakeError = {
-  name: string;
-  message: string;
-  stack?: string;
-};
-//#endregion
 //#region src/message.d.ts
 declare const MSGTYPE_QUERY = 0;
 declare const MSGTYPE_RESPONSE = 1;
 declare const MSGTYPE_HOST_ID = 2;
 declare const MSGTYPE_HOST_LOCK = 3;
-declare const MSGTYPE_WORKER_ERROR = 4;
-type QueryMessage = [typeof MSGTYPE_QUERY, number, unknown] | [typeof MSGTYPE_QUERY, number, unknown, number | undefined];
-type ResponseMessage = [typeof MSGTYPE_RESPONSE, number, FakeError] | [typeof MSGTYPE_RESPONSE, number, null, unknown];
-type HostIdMessage = [typeof MSGTYPE_HOST_ID, number];
-type HostLockMessage = [typeof MSGTYPE_HOST_LOCK, number, string];
-type WorkerErrorMessage = [typeof MSGTYPE_WORKER_ERROR, FakeError];
-type Message = QueryMessage | ResponseMessage | HostIdMessage | HostLockMessage | WorkerErrorMessage;
+declare const MSGTYPE_WORKER_LOCK = 4;
+declare const MSGTYPE_WORKER_ERROR = 5;
+type QueryMessage = [type: typeof MSGTYPE_QUERY, messageId: number, query: unknown] | [type: typeof MSGTYPE_QUERY, messageId: number, query: unknown, hostId: number | undefined];
+type ResponseMessage = [type: typeof MSGTYPE_RESPONSE, messageId: number, error: Error] | [type: typeof MSGTYPE_RESPONSE, messageId: number, error: null, result: unknown];
+type HostIdMessage = [type: typeof MSGTYPE_HOST_ID, hostId: number] | [type: typeof MSGTYPE_HOST_ID, hostId: number, workerLockId: string];
+type HostLockMessage = [type: typeof MSGTYPE_HOST_LOCK, hostID: number, hostLockId: string];
+type WorkerLockMessage = [type: typeof MSGTYPE_WORKER_LOCK, workerLockId: string];
+type WorkerErrorMessage = [type: typeof MSGTYPE_WORKER_ERROR, error: Error];
+type Message = QueryMessage | ResponseMessage | HostIdMessage | HostLockMessage | WorkerLockMessage | WorkerErrorMessage;
 //#endregion
 //#region src/PWBBase.d.ts
-type QueryCallback = (a: unknown, b: number | undefined) => any;
-declare abstract class PWBBase {
+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;
   constructor();
+  addEventListener<K extends keyof Events>(type: K, listener: ((event: Events[K]) => void) | {
+    handleEvent(object: Events[K]): void;
+  } | null, options?: AddEventListenerOptions | boolean): void;
+  dispatchEvent<K extends keyof Events>(event: Events[K]): boolean;
+  removeEventListener<K extends keyof Events>(type: K, listener: ((event: Events[K]) => void) | {
+    handleEvent(object: Events[K]): void;
+  } | null, options?: EventListenerOptions | boolean): void;
   register(cb: QueryCallback): void;
   protected abstract _postMessage(obj: Message, hostID?: number | undefined, transfer?: Transferable[] | undefined): void;
   private _postResponse;
   private _handleQuery;
-  protected _onMessageCommon(e: MessageEvent): HostIdMessage | HostLockMessage | WorkerErrorMessage | undefined;
+  protected _onMessageCommon(e: MessageEvent): [type: 2, hostId: number] | [type: 2, hostId: number, workerLockId: string] | HostLockMessage | WorkerLockMessage | WorkerErrorMessage | undefined;
 }
 //#endregion
 //#region src/PWBHost.d.ts
-type ErrorCallback = (a: Error) => void;
-export declare class PWBHost extends PWBBase {
-  private _errorCallback;
+type HostEvents = {
+  close: Event;
+  error: ErrorEvent;
+};
+export declare class PWBHost extends PWBBase<HostEvents> {
   private _hostID;
   private _hostIDQueue;
   private _worker;
   constructor(worker: SharedWorker | Worker);
-  registerError(cb: ErrorCallback): void;
   protected _postMessage(obj: QueryMessage | ResponseMessage | HostLockMessage, _hostID?: unknown, transfer?: Transferable[] | undefined): void;
   postMessage(userMessage: unknown, _hostID?: undefined, transfer?: Transferable[] | undefined): Promise<any>;
+  private handleWorkerLock;
   private _onMessage;
 }
 //#endregion
 //#region src/PWBWorker.d.ts
-export declare class PWBWorker extends PWBBase {
+type WorkerEvents = Record<string, Event>;
+export declare class PWBWorker extends PWBBase<WorkerEvents> {
   private _hosts;
   private _maxHostID;
   private _sharedWorker;
+  private _workerLockAcquired;
   constructor();
-  protected _postMessage(message: QueryMessage | ResponseMessage | HostIdMessage | WorkerErrorMessage, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): void;
+  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,46 +1,36 @@
-//#region src/fakeError.ts
-const isFakeError = (x) => {
-	if (typeof x !== "object" || x === null) return false;
-	const candidate = x;
-	if (typeof candidate.name !== "string" || typeof candidate.message !== "string") return false;
-	if (candidate.stack !== void 0 && typeof candidate.stack !== "string") return false;
+const isError = (error) => {
+	if (Error.isError) return Error.isError(error);
 	return true;
 };
-const toFakeError = (error) => {
-	const fakeError = {
-		name: error.name,
-		message: error.message
-	};
-	if (typeof error.stack === "string") fakeError.stack = error.stack;
-	return fakeError;
-};
-const fromFakeError = (fakeError) => {
-	return Object.assign(/* @__PURE__ */ new Error(), fakeError);
-};
 const parseMessage = (message) => {
 	if (!Array.isArray(message) || message.length < 2 || message.length > 4) return;
 	const type = message[0];
 	if (type === 0) {
 		if (typeof message[1] !== "number") throw new Error("Invalid messageID");
-		if (typeof message[3] !== "number" && message[3] !== void 0) throw new Error("Invalid hostID");
+		if (message[3] !== void 0 && typeof message[3] !== "number") throw new Error("Invalid hostID");
 		return message;
 	}
 	if (type === 1) {
 		if (typeof message[1] !== "number") throw new Error("Invalid messageID");
-		if (message[2] !== null && !isFakeError(message[2])) throw new Error("Invalid error");
+		if (message[2] !== null && !isError(message[2])) throw new Error("Invalid error");
 		return message;
 	}
 	if (type === 2) {
 		if (typeof message[1] !== "number") throw new Error("Invalid hostID");
+		if (message[2] !== void 0 && typeof message[2] !== "string") throw new Error("Invalid workerLockId");
 		return message;
 	}
 	if (type === 3) {
 		if (typeof message[1] !== "number") throw new Error("Invalid hostID");
-		if (typeof message[2] !== "string") throw new Error("Invalid lockId");
+		if (typeof message[2] !== "string") throw new Error("Invalid hostLockId");
 		return message;
 	}
 	if (type === 4) {
-		if (!isFakeError(message[1])) throw new Error("Invalid error");
+		if (typeof message[1] !== "string") throw new Error("Invalid workerLockId");
+		return message;
+	}
+	if (type === 5) {
+		if (!isError(message[1])) throw new Error("Invalid error");
 		return message;
 	}
 	throw new Error("Invalid message type");
@@ -49,20 +39,30 @@ const parseMessage = (message) => {
 //#region src/PWBBase.ts
 const isPromise = (obj) => !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
 const logError = (err) => {
-	console.error("Error in Worker:");
+	console.error("Error in worker:");
 	console.error(err);
 };
 const isSharedWorker = (worker) => {
 	return worker.port !== void 0;
 };
-var PWBBase = class {
+var PWBBase = class extends EventTarget {
 	_callbacks;
 	_queryCallback;
 	constructor() {
+		super();
 		this._callbacks = /* @__PURE__ */ new Map();
 		this._queryCallback = () => {};
 		this._onMessage = this._onMessage.bind(this);
 	}
+	addEventListener(type, listener, options) {
+		super.addEventListener(type, listener, options);
+	}
+	dispatchEvent(event) {
+		return super.dispatchEvent(event);
+	}
+	removeEventListener(type, listener, options) {
+		super.removeEventListener(type, listener, options);
+	}
 	register(cb) {
 		this._queryCallback = cb;
 	}
@@ -72,7 +72,7 @@ var PWBBase = class {
 			this._postMessage([
 				1,
 				messageID,
-				toFakeError(error)
+				error
 			], hostID);
 		} else if (typeof result === "object" && result !== null && Object.hasOwn(result, "message") && Object.hasOwn(result, "_PWB_TRANSFER")) this._postMessage([
 			1,
@@ -97,7 +97,7 @@ var PWBBase = class {
 			else result.then((finalResult) => {
 				this._postResponse(messageID, null, finalResult, hostID);
 			}, (finalError) => {
-				this._postResponse(messageID, finalError, hostID);
+				this._postResponse(messageID, finalError, void 0, hostID);
 			});
 		} catch (err) {
 			this._postResponse(messageID, err);
@@ -112,7 +112,7 @@ var PWBBase = class {
 		}
 		if (message[0] === 1) {
 			const messageID = message[1];
-			const error = message[2] === null ? null : fromFakeError(message[2]);
+			const error = message[2] === null ? null : message[2];
 			const callback = this._callbacks.get(messageID);
 			if (callback === void 0) return;
 			this._callbacks.delete(messageID);
@@ -126,7 +126,6 @@ var PWBBase = class {
 //#region src/PWBHost.ts
 let nextMessageID$1 = 0;
 var PWBHost = class extends PWBBase {
-	_errorCallback;
 	_hostID;
 	_hostIDQueue;
 	_worker;
@@ -140,13 +139,6 @@ var PWBHost = class extends PWBBase {
 		this._worker = worker;
 		this._hostIDQueue = [];
 	}
-	registerError(cb) {
-		this._errorCallback = cb;
-		this._worker.addEventListener("error", (e) => {
-			e.preventDefault();
-			e.stopPropagation();
-		});
-	}
 	_postMessage(obj, _hostID, transfer) {
 		if (isSharedWorker(this._worker)) {
 			if (transfer) this._worker.port.postMessage(obj, transfer);
@@ -177,6 +169,11 @@ var PWBHost = class extends PWBBase {
 			else actuallyPostMessage(resolve, reject);
 		});
 	}
+	handleWorkerLock(workerLockId) {
+		navigator.locks.request(workerLockId, { mode: "shared" }, async () => {
+			this.dispatchEvent(new Event("close"));
+		});
+	}
 	_onMessage(e) {
 		const message = this._onMessageCommon(e);
 		if (!message) return;
@@ -190,21 +187,20 @@ var PWBHost = class extends PWBBase {
 				}, 0);
 				this._hostIDQueue = void 0;
 			}
-			const lockId = `pwb-${Math.random()}`;
-			navigator.locks.request(lockId, async () => {
+			if (message[2] !== void 0) this.handleWorkerLock(message[2]);
+			const hostLockId = `pwb-host-${Math.random()}`;
+			navigator.locks.request(hostLockId, async () => {
 				this._postMessage([
 					3,
 					hostID,
-					lockId
+					hostLockId
 				]);
 				return new Promise(() => {});
 			});
-		} else if (message[0] === 4) {
-			if (message[1] !== null) {
-				const error = fromFakeError(message[1]);
-				if (this._errorCallback !== void 0) this._errorCallback(error);
-			}
-		}
+		} else if (message[0] === 5) {
+			const error = message[1];
+			this.dispatchEvent(new ErrorEvent("error", { error }));
+		} else if (message[0] === 4) this.handleWorkerLock(message[1]);
 	}
 };
 //#endregion
@@ -214,31 +210,49 @@ var PWBWorker = class extends PWBBase {
 	_hosts = /* @__PURE__ */ new Map();
 	_maxHostID = -1;
 	_sharedWorker;
+	_workerLockAcquired = false;
 	constructor() {
 		super();
+		const workerLockId = `pwb-worker-${Math.random()}`;
+		navigator.locks.request(workerLockId, async () => {
+			this._workerLockAcquired = true;
+			this._postMessage([4, workerLockId]);
+			return new Promise(() => {});
+		});
 		if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
 			this._sharedWorker = true;
-			self.addEventListener("connect", (e) => {
+			const _self = self;
+			_self.addEventListener("connect", (e) => {
 				const port = e.ports[0];
 				port.addEventListener("message", (e2) => this._onMessage(e2));
 				port.start();
 				this._maxHostID += 1;
 				const hostID = this._maxHostID;
 				this._hosts.set(hostID, { port });
-				this._postMessage([2, hostID], hostID);
+				let message;
+				if (this._workerLockAcquired) message = [
+					2,
+					hostID,
+					workerLockId
+				];
+				else message = [2, hostID];
+				this._postMessage(message, hostID);
 			});
-			self.addEventListener("error", (e) => {
+			_self.addEventListener("error", (e) => {
 				logError(e.error);
+				e.preventDefault();
 				const hostID = this._hosts.keys().next().value;
-				if (hostID !== void 0) this._postMessage([4, toFakeError(e.error)], hostID);
+				if (hostID !== void 0) this._postMessage([5, e.error], hostID);
 			});
 		} else {
 			this._sharedWorker = false;
-			self.addEventListener("message", this._onMessage);
+			const _self = self;
+			_self.addEventListener("message", this._onMessage);
 			this._postMessage([2, 0], 0);
-			self.addEventListener("error", (e) => {
+			_self.addEventListener("error", (e) => {
 				logError(e.error);
-				this._postMessage([4, toFakeError(e.error)]);
+				e.preventDefault();
+				this._postMessage([5, e.error]);
 			});
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "promise-worker-bi",
-	"version": "6.0.0-beta.0",
+	"version": "6.0.0",
 	"description": "Promise-based messaging for Web Workers and Shared Workers",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -14,8 +14,8 @@
 	"scripts": {
 		"prepack": "pnpm run build",
 		"build": "tsdown",
-		"lint": "pnpm run build && tsc && eslint .",
-		"test": "pnpm run build && vitest run",
+		"lint": "tsc && eslint .",
+		"test": "vitest run",
 		"prepare": "husky"
 	},
 	"repository": {