promise-worker-bi 4.1.1 → 5.0.1

package/README.md

@@ -8,7 +8,7 @@ This is based on [promise-worker](https://github.com/nolanlawson/promise-worker)
 
 Install:
 
-    yarn add promise-worker-bi
+    npm install promise-worker-bi
 
 Inside your main bundle:
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-declare type ErrorCallback = (a: Error) => void;
-declare type QueryCallback = (a: any[], b: number | undefined) => any;
+type ErrorCallback = (a: Error) => void;
+type QueryCallback = (a: any[], b: number | undefined) => any;
 declare abstract class PWBBase {
     _callbacks: Map<number, (a: Error | null, b: any) => void>;
     _queryCallback: QueryCallback;

package/dist/{esmodules.mjs → index.js}

@@ -4,96 +4,82 @@ const MSGTYPE_RESPONSE = 1;
 const MSGTYPE_HOST_ID = 2;
 const MSGTYPE_HOST_CLOSE = 3;
 const MSGTYPE_WORKER_ERROR = 4;
-const MSGTYPES = [MSGTYPE_QUERY, MSGTYPE_RESPONSE, MSGTYPE_HOST_ID, MSGTYPE_HOST_CLOSE, MSGTYPE_WORKER_ERROR]; // Inlined from https://github.com/then/is-promise
+const MSGTYPES = [MSGTYPE_QUERY, MSGTYPE_RESPONSE, MSGTYPE_HOST_ID, MSGTYPE_HOST_CLOSE, MSGTYPE_WORKER_ERROR];
 
+// Inlined from https://github.com/then/is-promise
 const isPromise = obj => !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
-
 const toFakeError = error => {
   const fakeError = {
     name: error.name,
     message: error.message
   };
-
   if (typeof error.stack === "string") {
     fakeError.stack = error.stack;
-  } // These are non-standard properties, I think only in some versions of Firefox
-  // @ts-expect-error
-
+  }
 
+  // These are non-standard properties, I think only in some versions of Firefox
+  // @ts-expect-error
   if (typeof error.fileName === "string") {
     // @ts-expect-error
     fakeError.fileName = error.fileName;
-  } // @ts-expect-error
-
-
+  }
+  // @ts-expect-error
   if (typeof error.columnNumber === "number") {
     // @ts-expect-error
     fakeError.columnNumber = error.columnNumber;
-  } // @ts-expect-error
-
-
+  }
+  // @ts-expect-error
   if (typeof error.lineNumber === "number") {
     // @ts-expect-error
     fakeError.lineNumber = error.lineNumber;
   }
-
   return fakeError;
-}; // Object rather than FakeError for convenience
-
+};
 
+// Object rather than FakeError for convenience
 const fromFakeError = fakeError => {
   const error = new Error();
   return Object.assign(error, fakeError);
 };
-
 const logError = err => {
   // Logging in the console makes debugging in the worker easier
-
-  /* eslint-disable no-console */
   console.error("Error in Worker:");
   console.error(err); // Safari needs it on new line
-
-  /* eslint-enable no-console */
 };
-
 class PWBBase {
   constructor() {
     // console.log('constructor', worker);
-    this._callbacks = new Map(); // eslint-disable-next-line @typescript-eslint/no-empty-function
-
-    this._queryCallback = () => {}; // @ts-expect-error
-
+    this._callbacks = new Map();
+    this._queryCallback = () => {};
 
+    // @ts-expect-error
     this._onMessage = this._onMessage.bind(this);
   }
-
   register(cb) {
     // console.log('register', cb);
     this._queryCallback = cb;
-  } // From worker, 2nd param could be hostID if sending to specific host. From UI, 2nd param could be an array of transferable objects
+  }
 
+  // From worker, 2nd param could be hostID if sending to specific host. From UI, 2nd param could be an array of transferable objects
 
   _postResponse(messageID, error, result, hostID) {
     // console.log('_postResponse', messageID, error, result);
     if (error) {
       logError(error);
-
       this._postMessage([MSGTYPE_RESPONSE, messageID, toFakeError(error)], hostID);
     } else {
       // Hackily identify when message contains transferable objects
-      if (typeof result === "object" && result !== null && result.hasOwnProperty("message") && result.hasOwnProperty("_PWB_TRANSFER")) {
+      if (typeof result === "object" && result !== null && Object.hasOwn(result, "message") && Object.hasOwn(result, "_PWB_TRANSFER")) {
         this._postMessage([MSGTYPE_RESPONSE, messageID, null, result.message], hostID, result._PWB_TRANSFER);
       } else {
         this._postMessage([MSGTYPE_RESPONSE, messageID, null, result], hostID);
       }
     }
   }
-
   _handleQuery(messageID, query, hostID) {
     // console.log('_handleQuery', messageID, query);
     try {
       const result = this._queryCallback(query, hostID);
-
       if (!isPromise(result)) {
         this._postResponse(messageID, null, result, hostID);
       } else {
@@ -106,78 +92,61 @@ class PWBBase {
     } catch (err) {
       this._postResponse(messageID, err);
     }
-  } // Either return messageID and type if further processing is needed, or undefined otherwise
-
+  }
 
+  // Either return messageID and type if further processing is needed, or undefined otherwise
   _onMessageCommon(e) {
-    // eslint-disable-line no-undef
     // console.log('_onMessage', e.data);
     const message = e.data;
-
     if (!Array.isArray(message) || message.length < 3 || message.length > 4) {
       return; // Ignore - this message is not for us
     }
-
     if (typeof message[0] !== "number" || MSGTYPES.indexOf(message[0]) < 0) {
       throw new Error("Invalid messageID");
     }
-
     const type = message[0];
-
     if (typeof message[1] !== "number") {
       throw new Error("Invalid messageID");
     }
-
     const messageID = message[1];
-
     if (type === MSGTYPE_QUERY) {
       const query = message[2];
-
       if (typeof message[3] !== "number" && message[3] !== undefined) {
         throw new Error("Invalid hostID");
       }
-
       const hostID = message[3];
-
       this._handleQuery(messageID, query, hostID);
-
       return;
     }
-
     if (type === MSGTYPE_RESPONSE) {
       if (message[2] !== null && typeof message[2] !== "object") {
         throw new Error("Invalid error");
       }
-
       const error = message[2] === null ? null : fromFakeError(message[2]);
       const result = message[3];
-
       const callback = this._callbacks.get(messageID);
-
       if (callback === undefined) {
         // Ignore - user might have created multiple PromiseWorkers.
         // This message is not for us.
         return;
       }
-
       this._callbacks.delete(messageID);
-
       callback(error, result);
       return;
     }
-
     return {
       message,
       type
     };
   }
-
 }
-
 class PWBHost extends PWBBase {
   // Only defined on host
+
   constructor(worker) {
-    super(); // The following if statement used to check `worker instanceof Worker` but I have recieved
+    super();
+
+    // The following if statement used to check `worker instanceof Worker` but I have recieved
     // reports that in some weird cases, Safari will inappropriately return false for that, even
     // in obvious cases like:
     //
@@ -187,21 +156,23 @@ class PWBHost extends PWBBase {
     //
     // So instead, let's do this test for worker.port which only exists on shared workers.
     // @ts-expect-error
-
     if (worker.port === undefined) {
-      this._workerType = "Worker"; // @ts-expect-error
+      this._workerType = "Worker";
 
+      // @ts-expect-error
       worker.addEventListener("message", this._onMessage);
     } else {
-      this._workerType = "SharedWorker"; // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
+      this._workerType = "SharedWorker";
 
-      worker.port.addEventListener("message", this._onMessage); // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
+      // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
+      worker.port.addEventListener("message", this._onMessage);
+      // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
+      worker.port.start();
 
-      worker.port.start(); // Handle tab close. This isn't perfect, but there is no perfect method
+      // Handle tab close. This isn't perfect, but there is no perfect method
       // http://stackoverflow.com/q/13662089/786644 and this should work like
       // 99% of the time. It is a memory leak if it fails, but for most use
       // cases, it shouldn't be noticeable.
-
       window.addEventListener("beforeunload", () => {
         // Prevent firing if we don't know hostID yet
         if (this._hostID !== undefined) {
@@ -209,22 +180,20 @@ class PWBHost extends PWBBase {
         }
       });
     }
-
     this._worker = worker;
     this._hostIDQueue = [];
   }
-
   registerError(cb) {
     // console.log('registerError', cb);
-    this._errorCallback = cb; // Some browsers (Firefox) call onerror on every host, while others
-    // (Chrome) do nothing. Let's disable that everywhere, for consistency.
+    this._errorCallback = cb;
 
+    // Some browsers (Firefox) call onerror on every host, while others
+    // (Chrome) do nothing. Let's disable that everywhere, for consistency.
     this._worker.addEventListener("error", e => {
       e.preventDefault();
       e.stopPropagation();
     });
   }
-
   _postMessage(obj, _hostID, transfer) {
     // console.log('_postMessage', obj, _hostID, transfer);
     if (this._workerType === "Worker") {
@@ -237,14 +206,12 @@ class PWBHost extends PWBBase {
       throw new Error("WTF");
     }
   }
-
   postMessage(userMessage, _hostID, transfer) {
     // console.log('postMessage', userMessage, _hostID, transfer);
     const actuallyPostMessage = (resolve, reject) => {
       const messageID = messageIDs;
       messageIDs += 1;
       const messageToSend = [MSGTYPE_QUERY, messageID, userMessage, this._hostID];
-
       this._callbacks.set(messageID, (error, result) => {
         if (error) {
           reject(error);
@@ -252,10 +219,8 @@ class PWBHost extends PWBBase {
           resolve(result);
         }
       });
-
       this._postMessage(messageToSend, undefined, transfer);
     };
-
     return new Promise((resolve, reject) => {
       // Don't send a message until hostID is known, otherwise it's a race
       // condition and sometimes hostID will be undefined.
@@ -268,25 +233,21 @@ class PWBHost extends PWBBase {
       }
     });
   }
-
   _onMessage(e) {
     const common = this._onMessageCommon(e);
-
     if (!common) {
       return;
     }
-
-    const message = common.message,
-          type = common.type;
-
+    const {
+      message,
+      type
+    } = common;
     if (type === MSGTYPE_HOST_ID) {
       if (message[2] !== undefined && typeof message[2] !== "number") {
         throw new Error("Invalid hostID");
       }
-
       const hostID = message[2];
       this._hostID = hostID;
-
       if (this._hostIDQueue !== undefined) {
         this._hostIDQueue.forEach(func => {
           // Not entirely sure why setTimeout is needed, might be just for unit tests
@@ -294,74 +255,68 @@ class PWBHost extends PWBBase {
             func();
           }, 0);
         });
-
         this._hostIDQueue = undefined; // Never needed again after initial setup
       }
     } else if (type === MSGTYPE_WORKER_ERROR) {
       if (message[2] !== undefined && message[2] !== null && typeof message[2] === "object") {
         const error = fromFakeError(message[2]);
-
         if (this._errorCallback !== undefined) {
           this._errorCallback(error);
         }
       }
     }
   }
-
 }
-
 class PWBWorker extends PWBBase {
   constructor() {
-    super(); // Only actually used for SharedWorker
+    super();
 
+    // Only actually used for SharedWorker
     this._hosts = new Map();
     this._maxHostID = -1;
-
-    if ( // @ts-expect-error
-    typeof SharedWorkerGlobalScope !== "undefined" && // @ts-expect-error
+    if (
+    // @ts-expect-error
+    typeof SharedWorkerGlobalScope !== "undefined" &&
+    // @ts-expect-error
     self instanceof SharedWorkerGlobalScope) {
       this._workerType = "SharedWorker";
       self.addEventListener("connect", e => {
         // @ts-expect-error
         const port = e.ports[0];
-        port.addEventListener("message", e2 => this._onMessage(e2)); // eslint-disable-line no-undef
-
+        port.addEventListener("message", e2 => this._onMessage(e2));
         port.start();
         this._maxHostID += 1;
         const hostID = this._maxHostID;
-
         this._hosts.set(hostID, {
           port
-        }); // Send back hostID to this host, otherwise it has no way to know it
-
+        });
 
+        // Send back hostID to this host, otherwise it has no way to know it
         this._postMessage([MSGTYPE_HOST_ID, -1, hostID], hostID);
       });
       self.addEventListener("error", e => {
-        logError(e.error); // Just send to first host, so as to not duplicate error tracking
+        logError(e.error);
 
+        // Just send to first host, so as to not duplicate error tracking
         const hostID = this._hosts.keys().next().value;
-
         if (hostID !== undefined) {
           this._postMessage([MSGTYPE_WORKER_ERROR, -1, toFakeError(e.error)], hostID);
         }
       });
     } else {
       this._workerType = "Worker";
-      self.addEventListener("message", this._onMessage); // Since this is not a Shared Worker, hostID is always 0 so it's not strictly required to
+      self.addEventListener("message", this._onMessage);
+
+      // Since this is not a Shared Worker, hostID is always 0 so it's not strictly required to
       // send this back, but it makes the API a bit more consistent if there is the same
       // initialization handshake in both cases.
-
       this._postMessage([MSGTYPE_HOST_ID, -1, 0], 0);
-
       self.addEventListener("error", e => {
         logError(e.error);
-
         this._postMessage([MSGTYPE_WORKER_ERROR, -1, toFakeError(e.error)]);
       });
     }
   }
-
   _postMessage(obj, targetHostID, transfer) {
     // console.log('_postMessage', obj, targetHostID);
     if (this._workerType === "SharedWorker") {
@@ -381,14 +336,12 @@ class PWBWorker extends PWBBase {
       throw new Error("WTF");
     }
   }
-
   postMessage(userMessage, targetHostID, transfer) {
     // console.log('postMessage', userMessage, targetHostID);
     const actuallyPostMessage = (resolve, reject) => {
       const messageID = messageIDs;
       messageIDs += 1;
       const messageToSend = [MSGTYPE_QUERY, messageID, userMessage];
-
       this._callbacks.set(messageID, (error, result) => {
         if (error) {
           reject(error);
@@ -396,36 +349,29 @@ class PWBWorker extends PWBBase {
           resolve(result);
         }
       });
-
       this._postMessage(messageToSend, targetHostID, transfer);
     };
-
     return new Promise((resolve, reject) => {
       actuallyPostMessage(resolve, reject);
     });
   }
-
   _onMessage(e) {
     const common = this._onMessageCommon(e);
-
     if (!common) {
       return;
     }
-
-    const message = common.message,
-          type = common.type;
-
+    const {
+      message,
+      type
+    } = common;
     if (type === MSGTYPE_HOST_CLOSE) {
       if (typeof message[2] !== "number") {
         throw new Error("Invalid hostID");
       }
-
       const hostID = message[2];
-
       this._hosts.delete(hostID);
     }
   }
-
 }
 
 export { PWBHost, PWBWorker };