webext-messenger 0.6.0 → 0.7.1

package/distribution/index.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="firefox-webext-browser" />
+import { Asyncify } from "type-fest";
 declare global {
     interface MessengerMethods {
         _: Method;
@@ -9,19 +10,19 @@ export declare type MessengerMeta = browser.runtime.MessageSender;
 declare type Arguments = any[];
 declare type Method = (this: MessengerMeta, ...args: Arguments) => Promise<unknown>;
 export interface Target {
-    tab: number;
-    frame?: number;
+    tabId: number;
+    frameId?: number;
 }
 declare type WithTarget<TMethod> = TMethod extends (...args: infer PreviousArguments) => infer TReturnValue ? (target: Target, ...args: PreviousArguments) => TReturnValue : never;
 /**
  * Replicates the original method, including its types.
  * To be called in the sender’s end.
  */
-export declare function getContentScriptMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], PublicMethod extends WithTarget<ActuallyOmitThisParameter<TMethod>>>(type: TType): PublicMethod;
+export declare function getContentScriptMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], PublicMethod extends WithTarget<Asyncify<ActuallyOmitThisParameter<TMethod>>>>(type: TType): PublicMethod;
 /**
  * Replicates the original method, including its types.
  * To be called in the sender’s end.
  */
-export declare function getMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], PublicMethod extends ActuallyOmitThisParameter<TMethod>>(type: TType): PublicMethod;
+export declare function getMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], PublicMethod extends Asyncify<ActuallyOmitThisParameter<TMethod>>>(type: TType): PublicMethod;
 export declare function registerMethods(methods: Partial<MessengerMethods>): void;
 export {};

package/distribution/index.js

@@ -1,29 +1,49 @@
 import { deserializeError, serializeError } from "serialize-error";
-const errorKey = "__webext_messenger_error_response__";
+const __webext_messenger__ = true;
 function isObject(value) {
     return typeof value === "object" && value !== null;
 }
-function isMessengerMessage(value) {
-    return (isObject(value) &&
-        typeof value["type"] === "string" &&
-        typeof value["__webext_messenger__"] === "boolean" &&
-        Array.isArray(value["args"]));
+function isMessengerMessage(message) {
+    return (isObject(message) &&
+        typeof message["type"] === "string" &&
+        message["__webext_messenger__"] === true &&
+        Array.isArray(message["args"]));
+}
+function isMessengerResponse(response) {
+    return isObject(response) && response["__webext_messenger__"] === true;
 }
 const handlers = new Map();
+async function handleMessage(message, sender) {
+    const handler = handlers.get(message.type);
+    if (!handler) {
+        throw new Error("No handler registered for " + message.type);
+    }
+    console.debug(`Messenger:`, message.type, message.args, "from", { sender });
+    // The handler could actually be a synchronous function
+    const response = await Promise.resolve(handler.call(sender, ...message.args)).then((value) => ({ value }), (error) => ({
+        // Errors must be serialized because the stacktraces are currently lost on Chrome and
+        // https://github.com/mozilla/webextension-polyfill/issues/210
+        error: serializeError(error),
+    }));
+    console.debug(`Messenger:`, message.type, "responds", response);
+    return { ...response, __webext_messenger__ };
+}
+async function handleResponse(response) {
+    if (!isMessengerResponse(response)) {
+        // If the response is `undefined`, `registerMethod` was never called
+        throw new Error("No handlers registered in receiving end");
+    }
+    if ("error" in response) {
+        throw deserializeError(response.error);
+    }
+    return response.value;
+}
 // MUST NOT be `async` or Promise-returning-only
 function onMessageListener(message, sender) {
-    if (!isMessengerMessage(message)) {
-        return;
-    }
-    const handler = handlers.get(message.type);
-    if (handler) {
-        return handler.call(sender, ...message.args).catch((error) => ({
-            // Errors must be serialized because the stacktraces are currently lost on Chrome and
-            // https://github.com/mozilla/webextension-polyfill/issues/210
-            [errorKey]: serializeError(error),
-        }));
+    if (isMessengerMessage(message)) {
+        return handleMessage(message, sender);
     }
-    throw new Error("No handler registered for " + message.type);
+    // TODO: Add test for this eventuality: ignore unrelated messages
 }
 /**
  * Replicates the original method, including its types.
@@ -32,21 +52,16 @@ function onMessageListener(message, sender) {
 export function getContentScriptMethod(type) {
     const publicMethod = async (target, ...args) => {
         var _a;
-        // TODO: This will throw if the receiving end doesn't exist,
-        //  i.e. if registerMethods hasn't been called
-        const response = await browser.tabs.sendMessage(target.tab, {
+        const response = await browser.tabs.sendMessage(target.tabId, {
             // Guarantees that a message is meant to be handled by this library
-            __webext_messenger__: true,
+            __webext_messenger__,
             type,
             args,
         }, {
             // Must be specified. If missing, the message would be sent to every frame
-            frameId: (_a = target.frame) !== null && _a !== void 0 ? _a : 0,
+            frameId: (_a = target.frameId) !== null && _a !== void 0 ? _a : 0,
         });
-        if (isObject(response) && errorKey in response) {
-            throw deserializeError(response[errorKey]);
-        }
-        return response;
+        return handleResponse(response);
     };
     return publicMethod;
 }
@@ -56,18 +71,13 @@ export function getContentScriptMethod(type) {
  */
 export function getMethod(type) {
     const publicMethod = async (...args) => {
-        // TODO: This will throw if the receiving end doesn't exist,
-        //  i.e. if registerMethods hasn't been called
         const response = await browser.runtime.sendMessage({
             // Guarantees that a message is meant to be handled by this library
-            __webext_messenger__: true,
+            __webext_messenger__,
             type,
             args,
         });
-        if (isObject(response) && errorKey in response) {
-            throw deserializeError(response[errorKey]);
-        }
-        return response;
+        return handleResponse(response);
     };
     return publicMethod;
 }
@@ -76,6 +86,7 @@ export function registerMethods(methods) {
         if (handlers.has(type)) {
             throw new Error(`Handler already set for ${type}`);
         }
+        console.debug(`Messenger: Registered`, type);
         handlers.set(type, method);
     }
     browser.runtime.onMessage.addListener(onMessageListener);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webext-messenger",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Browser Extension component messaging framework",
   "keywords": [],
   "repository": "pixiebrix/extension-messaging",
@@ -69,6 +69,7 @@
   },
   "dependencies": {
     "serialize-error": "^8.1.0",
+    "type-fest": "^2.3.4",
     "webext-detect-page": "^3.0.2",
     "webextension-polyfill": "^0.8.0"
   },