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

package/README.md

@@ -1,4 +1,10 @@
-# promise-worker-bi [![Build Status](https://travis-ci.org/dumbmatter/promise-worker-bi.svg?branch=master)](https://travis-ci.org/dumbmatter/promise-worker-bi)
+# promise-worker-bi
+
+[![Build Status](https://github.com/dumbmatter/promise-worker-bi/actions/workflows/nodejs.yml/badge.svg)](https://github.com/dumbmatter/promise-worker-bi/actions/workflows/nodejs.yml)
+[![GitHub Repo stars](https://img.shields.io/github/stars/dumbmatter/promise-worker-bi)](https://github.com/dumbmatter/promise-worker-bi)
+[![GitHub](https://img.shields.io/github/license/dumbmatter/promise-worker-bi)](https://github.com/dumbmatter/promise-worker-bi)
+[![npm](https://img.shields.io/npm/v/promise-worker-bi)](https://www.npmjs.com/package/promise-worker-bi)
+[![npm](https://img.shields.io/npm/dm/promise-worker-bi)](https://www.npmjs.com/package/promise-worker-bi)
 
 A small (~2 kB min+gz) and performant library for communicating with web workers and shared workers, using promises. Post a message from the browser to the worker, get a promise that resolves to the response. Post a message from the worker to the browser, get a promise that resolves to the response. And with shared workers, you can either broadcast to all browser tabs or send a message to a specific tab.
 
@@ -21,14 +27,14 @@ const promiseWorker = new PWBHost(worker);
 
 // Only needed if you send messages from the worker to the host
 promiseWorker.register((message) => {
-  return "pong2";
+	return "pong2";
 });
 
 try {
-  const response = await promiseWorker.postMessage("ping");
-  // handle response 'pong'
+	const response = await promiseWorker.postMessage("ping");
+	// handle response 'pong'
 } catch (error) {
-  // handle error
+	// handle error
 }
 ```
 
@@ -42,14 +48,14 @@ const promiseWorker = new PWBWorker();
 
 // Only needed if you send messages from the host to the worker
 promiseWorker.register((message) => {
-  return "pong";
+	return "pong";
 });
 
 try {
-  const response = await promiseWorker.postMessage("ping2");
-  // handle response 'pong2'
+	const response = await promiseWorker.postMessage("ping2");
+	// handle response 'pong2'
 } catch (error) {
-  // handle error
+	// handle error
 }
 ```
 
@@ -61,15 +67,15 @@ The message you send can be any object, array, string, number, etc. - anything t
 
 ```js
 await promiseWorker.postMessage({
-  hello: "world",
-  answer: 42,
-  "this is fun": true,
+	hello: "world",
+	answer: 42,
+	"this is fun": true,
 });
 ```
 
 ```js
 promiseWorker.register((message) => {
-  console.log(message); // { hello: 'world', answer: 42, 'this is fun': true }
+	console.log(message); // { hello: 'world', answer: 42, 'this is fun': true }
 });
 ```
 
@@ -79,7 +85,7 @@ The registered handler can return either a Promise or a normal value:
 
 ```js
 promiseWorker.register(async () => {
-  "much async, very promise";
+	"much async, very promise";
 });
 ```
 
@@ -94,15 +100,15 @@ Any thrown errors or asynchronous rejections during a response will be propagate
 
 ```js
 promiseWorker.register((message) => {
-  throw new Error("naughty!");
+	throw new Error("naughty!");
 });
 ```
 
 ```js
 try {
-  await promiseWorker.postMessage("whoops");
+	await promiseWorker.postMessage("whoops");
 } catch (error) {
-  console.log(error.message); // 'naughty!'
+	console.log(error.message); // 'naughty!'
 }
 ```
 
@@ -114,7 +120,7 @@ Therefore, promise-worker-bi includes a unified API that works in Web Workers an
 
 ```js
 promiseWorker.registerError((error) => {
-  console.log("Error inside worker!", err);
+	console.log("Error inside worker!", err);
 });
 ```
 
@@ -130,21 +136,21 @@ If you need to send messages of multiple types to the worker, just add some type
 
 ```js
 const response1 = await promiseWorker.postMessage({
-  type: "en",
+	type: "en",
 });
 
 const response2 = await promiseWorker.postMessage({
-  type: "en",
+	type: "en",
 });
 ```
 
 ```js
 promiseWorker.register((message) => {
-  if (message.type === "en") {
-    return "Hello!";
-  } else if (message.type === "fr") {
-    return "Bonjour!";
-  }
+	if (message.type === "en") {
+		return "Hello!";
+	} else if (message.type === "fr") {
+		return "Bonjour!";
+	}
 });
 ```
 
@@ -162,14 +168,14 @@ const worker = new SharedWorker("worker.js");
 const promiseWorker = new PWBHost(worker);
 
 promiseWorker.register((message) => {
-  console.log(message);
+	console.log(message);
 });
 
 // setTimeout is just to give you enough time to open main.js and main2.js in
 // two separate tabs.
 setTimeout(async () => {
-  const response = await promiseWorker.postMessage("broadcast");
-  console.log("Echoed response:", response);
+	const response = await promiseWorker.postMessage("broadcast");
+	console.log("Echoed response:", response);
 }, 1000);
 ```
 
@@ -199,13 +205,13 @@ import { PWBWorker } from "promise-worker-bi";
 const promiseWorker = new PWBWorker();
 
 promiseWorker.register((message, hostID) => {
-  if (message === "broadcast") {
-    promiseWorker.postMessage("to all tabs");
-  } else {
-    promiseWorker.postMessage(`hello host ${hostID}`, hostID);
-  }
+	if (message === "broadcast") {
+		promiseWorker.postMessage("to all tabs");
+	} else {
+		promiseWorker.postMessage(`hello host ${hostID}`, hostID);
+	}
 
-  return message;
+	return message;
 });
 ```
 
@@ -244,12 +250,12 @@ If you want to respond to a message by sending a transferable object back, such
 
 ```js
 promiseWorker.register(async (message) => {
-  const processedMessage = await processMessage(message);
+	const processedMessage = await processMessage(message);
 
-  return {
-    message: processedMessage,
-    _PWB_TRANSFER: [processedMessage.someTransferableProprty],
-  };
+	return {
+		message: processedMessage,
+		_PWB_TRANSFER: [processedMessage.someTransferableProprty],
+	};
 });
 ```
 

package/dist/index.d.ts

@@ -1,38 +1,58 @@
-type ErrorCallback = (a: Error) => void;
-type QueryCallback = (a: any[], b: number | undefined) => any;
+//#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;
+//#endregion
+//#region src/PWBBase.d.ts
+type QueryCallback = (a: unknown, b: number | undefined) => any;
 declare abstract class PWBBase {
-    _callbacks: Map<number, (a: Error | null, b: any) => void>;
-    _queryCallback: QueryCallback;
-    _workerType: "SharedWorker" | "Worker" | undefined;
-    constructor();
-    register(cb: QueryCallback): void;
-    abstract _postMessage(obj: any[], hostID?: number | undefined, transfer?: Transferable[] | undefined): void;
-    _postResponse(messageID: number, error: Error | null, result?: any, hostID?: number | undefined): void;
-    _handleQuery(messageID: number, query: any, hostID: number | undefined): void;
-    _onMessageCommon(e: MessageEvent): {
-        message: any;
-        type: number;
-    } | void;
+  protected _callbacks: Map<number, (a: Error | null, b: unknown) => void>;
+  protected _queryCallback: QueryCallback;
+  constructor();
+  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;
 }
-declare class PWBHost extends PWBBase {
-    _errorCallback: ErrorCallback | undefined;
-    _hostID: number | undefined;
-    _hostIDQueue: (() => void)[] | undefined;
-    _worker: SharedWorker | Worker;
-    constructor(worker: SharedWorker | Worker);
-    registerError(cb: ErrorCallback): void;
-    _postMessage(obj: any[], _hostID?: unknown, transfer?: Transferable[] | undefined): void;
-    postMessage(userMessage: any, _hostID?: undefined, transfer?: Transferable[] | undefined): Promise<any>;
-    _onMessage(e: MessageEvent): void;
+//#endregion
+//#region src/PWBHost.d.ts
+type ErrorCallback = (a: Error) => void;
+export declare class PWBHost extends PWBBase {
+  private _errorCallback;
+  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 _onMessage;
 }
-declare class PWBWorker extends PWBBase {
-    _hosts: Map<number, {
-        port: MessagePort;
-    }>;
-    _maxHostID: number;
-    constructor();
-    _postMessage(obj: any[], targetHostID?: number | undefined, transfer?: Transferable[] | undefined): void;
-    postMessage(userMessage: any, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): Promise<any>;
-    _onMessage(e: MessageEvent): void;
+//#endregion
+//#region src/PWBWorker.d.ts
+export declare class PWBWorker extends PWBBase {
+  private _hosts;
+  private _maxHostID;
+  private _sharedWorker;
+  constructor();
+  protected _postMessage(message: QueryMessage | ResponseMessage | HostIdMessage | WorkerErrorMessage, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): void;
+  postMessage(userMessage: unknown, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): Promise<unknown>;
+  private _onMessage;
 }
-export { PWBHost, PWBWorker };
+//#endregion