webext-messenger 0.7.1 → 0.9.2

package/distribution/index.d.ts

@@ -1,11 +1,15 @@
 /// <reference types="firefox-webext-browser" />
-import { Asyncify } from "type-fest";
+import { Asyncify, SetReturnType, ValueOf } from "type-fest";
 declare global {
     interface MessengerMethods {
         _: Method;
     }
 }
+declare type WithTarget<TMethod> = TMethod extends (...args: infer PreviousArguments) => infer TReturnValue ? (target: Target, ...args: PreviousArguments) => TReturnValue : never;
 declare type ActuallyOmitThisParameter<T> = T extends (...args: infer A) => infer R ? (...args: A) => R : T;
+/** Removes the `this` type and ensure it's always Promised */
+declare type PublicMethod<TMethod extends ValueOf<MessengerMethods>> = Asyncify<ActuallyOmitThisParameter<TMethod>>;
+declare type PublicMethodWithTarget<TMethod extends ValueOf<MessengerMethods>> = WithTarget<PublicMethod<TMethod>>;
 export declare type MessengerMeta = browser.runtime.MessageSender;
 declare type Arguments = any[];
 declare type Method = (this: MessengerMeta, ...args: Arguments) => Promise<unknown>;
@@ -13,16 +17,28 @@ export interface Target {
     tabId: number;
     frameId?: number;
 }
-declare type WithTarget<TMethod> = TMethod extends (...args: infer PreviousArguments) => infer TReturnValue ? (target: Target, ...args: PreviousArguments) => TReturnValue : never;
+interface Options {
+    /**
+     * "Notifications" won't await the response, return values, attempt retries, nor throw errors
+     * @default false
+     */
+    isNotification?: boolean;
+}
 /**
  * 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<Asyncify<ActuallyOmitThisParameter<TMethod>>>>(type: TType): PublicMethod;
+declare function getContentScriptMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], TPublicMethod extends PublicMethodWithTarget<TMethod>>(type: TType, options: {
+    isNotification: true;
+}): SetReturnType<TPublicMethod, void>;
+declare function getContentScriptMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], TPublicMethod extends PublicMethodWithTarget<TMethod>>(type: TType, options?: Options): TPublicMethod;
 /**
  * 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 Asyncify<ActuallyOmitThisParameter<TMethod>>>(type: TType): PublicMethod;
-export declare function registerMethods(methods: Partial<MessengerMethods>): void;
-export {};
+declare function getMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], TPublicMethod extends PublicMethod<TMethod>>(type: TType, options: {
+    isNotification: true;
+}): SetReturnType<TPublicMethod, void>;
+declare function getMethod<TType extends keyof MessengerMethods, TMethod extends MessengerMethods[TType], TPublicMethod extends PublicMethod<TMethod>>(type: TType, options?: Options): TPublicMethod;
+declare function registerMethods(methods: Partial<MessengerMethods>): void;
+export { getMethod, getContentScriptMethod, registerMethods };

package/distribution/index.js

@@ -1,3 +1,4 @@
+import pRetry from "p-retry";
 import { deserializeError, serializeError } from "serialize-error";
 const __webext_messenger__ = true;
 function isObject(value) {
@@ -28,7 +29,28 @@ async function handleMessage(message, sender) {
     console.debug(`Messenger:`, message.type, "responds", response);
     return { ...response, __webext_messenger__ };
 }
-async function handleResponse(response) {
+// Do not turn this into an `async` function; Notifications must turn `void`
+function manageConnection(type, options, sendMessage) {
+    if (!options.isNotification) {
+        return manageMessage(type, sendMessage);
+    }
+    void sendMessage().catch((error) => {
+        console.debug("Messenger:", type, "notification failed", { error });
+    });
+}
+async function manageMessage(type, sendMessage) {
+    const response = await pRetry(sendMessage, {
+        minTimeout: 100,
+        factor: 1.3,
+        maxRetryTime: 4000,
+        onFailedAttempt(error) {
+            if ((error === null || error === void 0 ? void 0 : error.message) !==
+                "Could not establish connection. Receiving end does not exist.") {
+                throw error;
+            }
+            console.debug("Messenger:", type, "will retry");
+        },
+    });
     if (!isMessengerResponse(response)) {
         // If the response is `undefined`, `registerMethod` was never called
         throw new Error("No handlers registered in receiving end");
@@ -45,43 +67,33 @@ function onMessageListener(message, sender) {
     }
     // TODO: Add test for this eventuality: ignore unrelated messages
 }
-/**
- * Replicates the original method, including its types.
- * To be called in the sender’s end.
- */
-export function getContentScriptMethod(type) {
-    const publicMethod = async (target, ...args) => {
-        var _a;
-        const response = await browser.tabs.sendMessage(target.tabId, {
-            // Guarantees that a message is meant to be handled by this library
-            __webext_messenger__,
-            type,
-            args,
-        }, {
-            // Must be specified. If missing, the message would be sent to every frame
-            frameId: (_a = target.frameId) !== null && _a !== void 0 ? _a : 0,
-        });
-        return handleResponse(response);
+function makeMessage(type, args) {
+    return {
+        __webext_messenger__,
+        type,
+        args,
+    };
+}
+function getContentScriptMethod(type, options = {}) {
+    const publicMethod = (target, ...args) => {
+        const sendMessage = async () => {
+            var _a;
+            return browser.tabs.sendMessage(target.tabId, makeMessage(type, args), 
+            // `frameId` must be specified. If missing, the message would be sent to every frame
+            { frameId: (_a = target.frameId) !== null && _a !== void 0 ? _a : 0 });
+        };
+        return manageConnection(type, options, sendMessage);
     };
     return publicMethod;
 }
-/**
- * Replicates the original method, including its types.
- * To be called in the sender’s end.
- */
-export function getMethod(type) {
-    const publicMethod = async (...args) => {
-        const response = await browser.runtime.sendMessage({
-            // Guarantees that a message is meant to be handled by this library
-            __webext_messenger__,
-            type,
-            args,
-        });
-        return handleResponse(response);
+function getMethod(type, options = {}) {
+    const publicMethod = (...args) => {
+        const sendMessage = async () => browser.runtime.sendMessage(makeMessage(type, args));
+        return manageConnection(type, options, sendMessage);
     };
     return publicMethod;
 }
-export function registerMethods(methods) {
+function registerMethods(methods) {
     for (const [type, method] of Object.entries(methods)) {
         if (handlers.has(type)) {
             throw new Error(`Handler already set for ${type}`);
@@ -91,3 +103,4 @@ export function registerMethods(methods) {
     }
     browser.runtime.onMessage.addListener(onMessageListener);
 }
+export { getMethod, getContentScriptMethod, registerMethods };

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "webext-messenger",
-  "version": "0.7.1",
+  "version": "0.9.2",
   "description": "Browser Extension component messaging framework",
   "keywords": [],
   "repository": "pixiebrix/extension-messaging",
   "license": "MIT",
   "author": "Federico Brigante for PixieBrix <federico@pixiebrix.com> (https://www.pixiebrix.com)",
   "type": "module",
-  "main": "distribution/index.js",
+  "exports": "./distribution/index.js",
+  "types": "distribution/index.d.ts",
   "files": [
     "distribution/index.js",
     "distribution/index.d.ts"
@@ -42,18 +43,19 @@
       "plugin:unicorn/recommended"
     ],
     "rules": {
-      "@typescript-eslint/no-require-imports": "off",
       "@typescript-eslint/no-unsafe-member-access": "off",
-      "import/extensions": "off",
-      "import/no-unassigned-import": "off",
-      "node/file-extension-in-import": "off",
       "unicorn/filename-case": [
         "error",
         {
           "case": "camelCase"
         }
       ],
-      "unicorn/prefer-module": "off",
+      "unicorn/no-useless-undefined": [
+        "error",
+        {
+          "checkArguments": false
+        }
+      ],
       "unicorn/prevent-abbreviations": [
         "error",
         {
@@ -63,11 +65,22 @@
         }
       ]
     },
+    "overrides": [
+      {
+        "files": [
+          "*.test.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/no-non-null-assertion": "off"
+        }
+      }
+    ],
     "globals": {
       "chrome": true
     }
   },
   "dependencies": {
+    "p-retry": "^4.6.1",
     "serialize-error": "^8.1.0",
     "type-fest": "^2.3.4",
     "webext-detect-page": "^3.0.2",
@@ -76,20 +89,20 @@
   "devDependencies": {
     "@parcel/config-webextension": "^2.0.0-rc.0",
     "@sindresorhus/tsconfig": "^2.0.0",
-    "@types/chrome": "^0.0.154",
+    "@types/chrome": "^0.0.158",
     "@types/firefox-webext-browser": "^82.0.1",
-    "@typescript-eslint/eslint-plugin": "^4.30.0",
-    "@typescript-eslint/parser": "^4.30.0",
+    "@typescript-eslint/eslint-plugin": "^4.31.2",
+    "@typescript-eslint/parser": "^4.31.2",
     "eslint": "^7.32.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-config-xo": "^0.38.0",
     "eslint-config-xo-typescript": "^0.44.0",
     "eslint-plugin-import": "^2.24.2",
-    "eslint-plugin-unicorn": "^35.0.0",
+    "eslint-plugin-unicorn": "^36.0.0",
     "fresh-tape": "^5.3.1",
     "npm-run-all": "^4.1.5",
     "parcel": "^2.0.0-rc.0",
-    "typescript": "^4.4.2",
+    "typescript": "^4.4.3",
     "xo": "^0.44.0"
   },
   "targets": {