webext-messenger 0.13.0-8 → 0.14.1

package/distribution/api.d.ts

@@ -0,0 +1,10 @@
+import { Target, MessengerMeta } from "./types";
+declare function __getTabData(this: MessengerMeta): Target;
+declare global {
+    interface MessengerMethods {
+        __getTabData: typeof __getTabData;
+    }
+}
+export declare const getTabData: () => Promise<Target>;
+export declare function initPrivateApi(): void;
+export {};

package/distribution/api.js

@@ -0,0 +1,13 @@
+import { getMethod } from "./sender";
+import { registerMethods } from "./receiver";
+import { isBackgroundPage } from "webext-detect-page";
+function __getTabData() {
+    return { tabId: this.trace[0].tab.id, frameId: this.trace[0].frameId };
+}
+// First page to respond wins. Any context has this piece of information.
+export const getTabData = getMethod("__getTabData", { page: "any" });
+export function initPrivateApi() {
+    if (isBackgroundPage()) {
+        registerMethods({ __getTabData });
+    }
+}

package/distribution/index.d.ts

@@ -1,3 +1,3 @@
-export { registerMethods } from "./receiver.js";
-export { getContentScriptMethod, getMethod } from "./sender.js";
-export { MessengerMeta, Target } from "./types.js";
+export * from "./receiver.js";
+export * from "./sender.js";
+export * from "./types.js";

package/distribution/index.js

@@ -1,2 +1,8 @@
-export { registerMethods } from "./receiver.js";
-export { getContentScriptMethod, getMethod } from "./sender.js";
+// Imports must use the .js extension because of ESM requires it and TS refuses to rewrite .ts to .js
+// This works in TS even if the .js doesn't exist, but it breaks Parcel (the tests builder)
+// For this reason, there's an `alias` field in package.json to redirect these imports.
+// If you see "@parcel/resolver-default: Cannot load file './yourNewFile.js'" you need to add it to the `alias` list
+// 🥲
+export * from "./receiver.js";
+export * from "./sender.js";
+export * from "./types.js";

package/distribution/receiver.js

@@ -1,5 +1,6 @@
+import browser from "webextension-polyfill";
 import { serializeError } from "serialize-error";
-import { getContentScriptMethod } from "./sender.js";
+import { messenger } from "./sender.js";
 import { handlers, isObject, MessengerError, debug, warn, __webextMessenger, } from "./shared.js";
 export function isMessengerMessage(message) {
     return (isObject(message) &&
@@ -21,8 +22,7 @@ function onMessageListener(message, sender) {
             throw new MessengerError(`Message ${type} sent to wrong context, it can't be forwarded to ${JSON.stringify(target)}`);
         }
         debug(type, "🔀 forwarded", { sender, target });
-        const publicMethod = getContentScriptMethod(type);
-        handleMessage = async () => publicMethod(target, ...args);
+        handleMessage = async () => messenger(type, {}, target, ...args);
     }
     else {
         const localHandler = handlers.get(type);
@@ -50,13 +50,8 @@ export function registerMethods(methods) {
         if (handlers.has(type)) {
             throw new MessengerError(`Handler already set for ${type}`);
         }
-        console.debug(`Messenger: Registered`, type);
+        console.debug("Messenger: Registered", type);
         handlers.set(type, method);
     }
-    if ("browser" in globalThis) {
-        browser.runtime.onMessage.addListener(onMessageListener);
-    }
-    else {
-        throw new Error("`webext-messenger` requires `webextension");
-    }
+    browser.runtime.onMessage.addListener(onMessageListener);
 }

package/distribution/sender.d.ts

@@ -1,20 +1,13 @@
+import { PublicMethod, PublicMethodWithTarget, Options, Target, PageTarget } from "./types.js";
 import { SetReturnType } from "type-fest";
-import { PublicMethod, PublicMethodWithTarget, Options } from "./types.js";
 export declare const errorNonExistingTarget = "Could not establish connection. Receiving end does not exist.";
-/**
- * Replicates the original method, including its types.
- * To be called in the sender’s end.
- */
-declare function getContentScriptMethod<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethod extends PublicMethodWithTarget<Method>>(type: Type, options: {
+declare function messenger<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type]>(type: Type, options: {
     isNotification: true;
-}): SetReturnType<PublicMethod, void>;
-declare function getContentScriptMethod<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethod extends PublicMethodWithTarget<Method>>(type: Type, options?: Options): PublicMethod;
-/**
- * Replicates the original method, including its types.
- * To be called in the sender’s end.
- */
-declare function getMethod<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethodType extends PublicMethod<Method>>(type: Type, options: {
-    isNotification: true;
-}): SetReturnType<PublicMethodType, void>;
-declare function getMethod<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethodType extends PublicMethod<Method>>(type: Type, options?: Options): PublicMethodType;
-export { getContentScriptMethod, getMethod };
+}, target: Target | PageTarget, ...args: Parameters<Method>): void;
+declare function messenger<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], ReturnValue extends ReturnType<Method>>(type: Type, options: Options, target: Target | PageTarget, ...args: Parameters<Method>): ReturnValue;
+declare function getMethod<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethodType extends PublicMethod<Method>>(type: Type, target: Target | PageTarget): PublicMethodType;
+declare function getMethod<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethodWithDynamicTarget extends PublicMethodWithTarget<Method>>(type: Type): PublicMethodWithDynamicTarget;
+declare function getNotifier<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethodType extends SetReturnType<PublicMethod<Method>, void>>(type: Type, target: Target | PageTarget): PublicMethodType;
+declare function getNotifier<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], PublicMethodWithDynamicTarget extends SetReturnType<PublicMethodWithTarget<Method>, void>>(type: Type): PublicMethodWithDynamicTarget;
+export { messenger, getMethod, getNotifier };
+export declare const backgroundTarget: PageTarget;

package/distribution/sender.js

@@ -1,3 +1,4 @@
+import browser from "webextension-polyfill";
 import pRetry from "p-retry";
 import { isBackgroundPage } from "webext-detect-page";
 import { deserializeError } from "serialize-error";
@@ -45,30 +46,9 @@ async function manageMessage(type, sendMessage) {
     debug(type, "↘️ replied successfully", response.value);
     return response.value;
 }
-function getContentScriptMethod(type, options = {}) {
-    const publicMethod = (target, ...args) => {
-        // Contexts without direct Tab access must go through background
-        if (!browser.tabs) {
-            return manageConnection(type, options, async () => {
-                debug(type, "↗️ sending message to runtime");
-                return browser.runtime.sendMessage(makeMessage(type, args, target));
-            });
-        }
-        // `frameId` must be specified. If missing, the message is sent to every frame
-        const { tabId, frameId = 0 } = target;
-        // Message tab directly
-        return manageConnection(type, options, async () => {
-            debug(type, "↗️ sending message to tab", tabId, "frame", frameId);
-            return browser.tabs.sendMessage(tabId, makeMessage(type, args), {
-                frameId,
-            });
-        });
-    };
-    return publicMethod;
-}
-function getMethod(type, options = {}) {
-    const publicMethod = (...args) => {
-        if (isBackgroundPage()) {
+function messenger(type, options, target, ...args) {
+    if ("page" in target) {
+        if (target.page === "background" && isBackgroundPage()) {
             const handler = handlers.get(type);
             if (handler) {
                 warn(type, "is being handled locally");
@@ -81,7 +61,39 @@ function getMethod(type, options = {}) {
             return browser.runtime.sendMessage(makeMessage(type, args));
         };
         return manageConnection(type, options, sendMessage);
-    };
-    return publicMethod;
+    }
+    // Contexts without direct Tab access must go through background
+    if (!browser.tabs) {
+        return manageConnection(type, options, async () => {
+            debug(type, "↗️ sending message to runtime");
+            return browser.runtime.sendMessage(makeMessage(type, args, target));
+        });
+    }
+    // `frameId` must be specified. If missing, the message is sent to every frame
+    const { tabId, frameId = 0 } = target;
+    // Message tab directly
+    return manageConnection(type, options, async () => {
+        debug(type, "↗️ sending message to tab", tabId, "frame", frameId);
+        return browser.tabs.sendMessage(tabId, makeMessage(type, args), {
+            frameId,
+        });
+    });
+}
+function getMethod(type, target) {
+    if (arguments.length === 1) {
+        return messenger.bind(undefined, type, {});
+    }
+    // @ts-expect-error `bind` types are junk
+    return messenger.bind(undefined, type, {}, target);
+}
+function getNotifier(type, target) {
+    const options = { isNotification: true };
+    if (arguments.length === 1) {
+        // @ts-expect-error `bind` types are junk
+        return messenger.bind(undefined, type, options);
+    }
+    // @ts-expect-error `bind` types are junk
+    return messenger.bind(undefined, type, options, target);
 }
-export { getContentScriptMethod, getMethod };
+export { messenger, getMethod, getNotifier };
+export const backgroundTarget = { page: "background" };

package/distribution/thisTarget.d.ts

@@ -0,0 +1,12 @@
+import { Target, PageTarget, MessengerMeta } from "./types.js";
+declare type AnyTarget = Partial<Target & PageTarget>;
+export declare function getActionForMessage(target: AnyTarget): "respond" | "forward" | "ignore";
+export declare function nameThisTarget(): Promise<void>;
+declare function __getTabData(this: MessengerMeta): AnyTarget;
+declare global {
+    interface MessengerMethods {
+        __getTabData: typeof __getTabData;
+    }
+}
+export declare function initPrivateApi(): void;
+export {};

package/distribution/thisTarget.js

@@ -0,0 +1,53 @@
+import { isBackgroundPage, isContentScript } from "webext-detect-page";
+import { messenger } from "./sender.js";
+import { registerMethods } from "./receiver.js";
+import { debug } from "./shared.js";
+// Soft warning: Race conditions are possible.
+// This CANNOT be awaited because waiting for it means "I will handle the message."
+// If a message is received before this is ready, it will just have to be ignored.
+let thisTarget;
+//
+export function getActionForMessage(target) {
+    if (target.page === "any") {
+        return "respond";
+    }
+    // Content scripts only receive messages that are meant for them. In the future
+    // they'll also forward them, but that still means they need to be handled here.
+    if (isContentScript()) {
+        return "respond";
+    }
+    // We're in an extension page, but the target is not one.
+    if (!("page" in target)) {
+        return "forward";
+    }
+    if (!thisTarget) {
+        console.warn("A message was received before this context was ready");
+        // If this *was* the target, then probably no one else answered
+        return "ignore";
+    }
+    // Every `target` key must match `thisTarget`
+    const isThisTarget = Object.entries(target).every(
+    // @ts-expect-error Optional properties
+    ([key, value]) => thisTarget[key] === value);
+    if (!isThisTarget) {
+        debug("The message’s target is", target, "but this is", thisTarget);
+    }
+    return isThisTarget ? "respond" : "ignore";
+}
+export async function nameThisTarget() {
+    // Same as above: CS receives messages correctly
+    if (!thisTarget && !isContentScript()) {
+        thisTarget = await messenger("__getTabData", {}, { page: "any" });
+        thisTarget.page = location.pathname;
+    }
+}
+function __getTabData() {
+    var _a, _b, _c;
+    return { tabId: (_b = (_a = this.trace[0]) === null || _a === void 0 ? void 0 : _a.tab) === null || _b === void 0 ? void 0 : _b.id, frameId: (_c = this.trace[0]) === null || _c === void 0 ? void 0 : _c.frameId };
+}
+export function initPrivateApi() {
+    if (isBackgroundPage()) {
+        thisTarget = { page: "background" };
+        registerMethods({ __getTabData });
+    }
+}

package/distribution/types.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="firefox-webext-browser" />
+import { Runtime } from "webextension-polyfill";
 import { Asyncify, ValueOf } from "type-fest";
 import { ErrorObject } from "serialize-error";
 declare global {
@@ -12,7 +12,7 @@ declare type ActuallyOmitThisParameter<T> = T extends (...args: infer A) => infe
 export declare type PublicMethod<Method extends ValueOf<MessengerMethods>> = Asyncify<ActuallyOmitThisParameter<Method>>;
 export declare type PublicMethodWithTarget<Method extends ValueOf<MessengerMethods>> = WithTarget<PublicMethod<Method>>;
 export interface MessengerMeta {
-    trace: browser.runtime.MessageSender[];
+    trace: Runtime.MessageSender[];
 }
 declare type RawMessengerResponse = {
     value: unknown;
@@ -48,4 +48,8 @@ export interface Target {
     tabId: number;
     frameId?: number;
 }
+export interface PageTarget {
+    tabId?: number;
+    page: string;
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webext-messenger",
-  "version": "0.13.0-8",
+  "version": "0.14.1",
   "description": "Browser Extension component messaging framework",
   "keywords": [],
   "repository": "pixiebrix/webext-messenger",
@@ -17,8 +17,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "demo:watch": "parcel watch --no-cache --no-hmr --detailed-report 0",
-    "demo:build": "parcel build --no-cache --detailed-report 0",
+    "demo:watch": "parcel watch --no-cache --no-hmr",
+    "demo:build": "parcel build --no-cache",
     "prepack": "tsc --sourceMap false",
     "test": "eslint . && tsc --noEmit",
     "lint": "eslint .",
@@ -45,6 +45,21 @@
       "plugin:unicorn/recommended"
     ],
     "rules": {
+      "no-restricted-imports": [
+        "error",
+        {
+          "paths": [
+            {
+              "name": "./index",
+              "message": "The index file is only used to re-export internal files. Use direct imports instead."
+            }
+          ]
+        }
+      ],
+      "import/extensions": [
+        "error",
+        "always"
+      ],
       "import/no-unresolved": "off",
       "unicorn/filename-case": [
         "error",
@@ -77,37 +92,42 @@
           "@typescript-eslint/no-explicit-any": "off",
           "@typescript-eslint/no-unsafe-member-access": "off"
         }
+      },
+      {
+        "files": [
+          "source/test/**/*"
+        ],
+        "rules": {
+          "import/extensions": "off"
+        }
       }
-    ],
-    "globals": {
-      "chrome": true
-    }
+    ]
   },
   "dependencies": {
-    "p-retry": "^4.6.1",
-    "serialize-error": "^8.1.0",
-    "type-fest": "^2.5.1",
-    "webext-detect-page": "^3.0.2",
+    "p-retry": "^5.0.0",
+    "serialize-error": "^9.0.0",
+    "type-fest": "^2.6.0",
+    "webext-detect-page": "^3.1.0",
     "webextension-polyfill": "^0.8.0"
   },
   "devDependencies": {
-    "@parcel/config-webextension": "^2.0.0",
+    "@parcel/config-webextension": "^2.0.1",
     "@sindresorhus/tsconfig": "^2.0.0",
-    "@types/chrome": "^0.0.159",
-    "@types/firefox-webext-browser": "^94.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.1.0",
-    "@typescript-eslint/parser": "^5.1.0",
-    "eslint": "^8.1.0",
+    "@types/chrome": "^0.0.164",
+    "@types/tape": "^4.13.2",
+    "@types/webextension-polyfill": "^0.8.2",
+    "@typescript-eslint/eslint-plugin": "^5.4.0",
+    "@typescript-eslint/parser": "^5.4.0",
+    "eslint": "^8.3.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-config-xo": "^0.39.0",
-    "eslint-config-xo-typescript": "^0.45.2",
-    "eslint-plugin-import": "^2.25.2",
-    "eslint-plugin-unicorn": "^37.0.1",
-    "fresh-tape": "^5.3.1",
+    "eslint-config-xo-typescript": "^0.47.1",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-unicorn": "^39.0.0",
     "npm-run-all": "^4.1.5",
-    "parcel": "^2.0.0",
-    "typescript": "^4.4.4",
-    "xo": "^0.45.0"
+    "parcel": "^2.0.1",
+    "tape": "^5.3.2",
+    "typescript": "^4.5.2"
   },
   "targets": {
     "main": false,