webext-messenger 0.14.1 → 0.15.0-3

package/distribution/index.js

@@ -6,3 +6,5 @@
 export * from "./receiver.js";
 export * from "./sender.js";
 export * from "./types.js";
+import { initPrivateApi } from "./thisTarget.js";
+initPrivateApi();

package/distribution/receiver.js

@@ -1,7 +1,9 @@
 import browser from "webextension-polyfill";
 import { serializeError } from "serialize-error";
 import { messenger } from "./sender.js";
-import { handlers, isObject, MessengerError, debug, warn, __webextMessenger, } from "./shared.js";
+import { handlers, isObject, MessengerError, debug, __webextMessenger, } from "./shared.js";
+import { getContextName } from "webext-detect-page";
+import { getActionForMessage, nameThisTarget } from "./thisTarget.js";
 export function isMessengerMessage(message) {
     return (isObject(message) &&
         typeof message["type"] === "string" &&
@@ -14,21 +16,27 @@ function onMessageListener(message, sender) {
         // TODO: Add test for this eventuality: ignore unrelated messages
         return;
     }
-    const { type, target, args } = message;
+    // Target check must be synchronous (`await` means we're handing the message)
+    const action = getActionForMessage(sender, message.target);
+    if (action === "ignore") {
+        return;
+    }
+    return handleMessage(message, sender, action);
+}
+// This function can only be called when the message *will* be handled locally.
+// Returning "undefined" or throwing an error will still handle it.
+async function handleMessage(message, sender, action) {
+    const { type, target, args, options: { trace } = {} } = message;
     debug(type, "↘️ received", { sender, args });
     let handleMessage;
-    if (target) {
-        if (!browser.tabs) {
-            throw new MessengerError(`Message ${type} sent to wrong context, it can't be forwarded to ${JSON.stringify(target)}`);
-        }
+    if (action === "forward") {
         debug(type, "🔀 forwarded", { sender, target });
-        handleMessage = async () => messenger(type, {}, target, ...args);
+        handleMessage = async () => messenger(type, { trace }, target, ...args);
     }
     else {
         const localHandler = handlers.get(type);
         if (!localHandler) {
-            warn(type, "⚠️ ignored, can't be handled here");
-            return;
+            throw new MessengerError(`No handler registered for ${type} in ${getContextName()}`);
         }
         debug(type, "➡️ will be handled here");
         const meta = { trace: [sender] };
@@ -46,6 +54,7 @@ function onMessageListener(message, sender) {
     });
 }
 export function registerMethods(methods) {
+    void nameThisTarget();
     for (const [type, method] of Object.entries(methods)) {
         if (handlers.has(type)) {
             throw new MessengerError(`Handler already set for ${type}`);

package/distribution/sender.d.ts

@@ -4,7 +4,7 @@ export declare const errorNonExistingTarget = "Could not establish connection. R
 declare function messenger<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type]>(type: Type, options: {
     isNotification: true;
 }, 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 messenger<Type extends keyof MessengerMethods, Method extends MessengerMethods[Type], ReturnValue extends Promise<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;

package/distribution/sender.js

@@ -7,12 +7,13 @@ export const errorNonExistingTarget = "Could not establish connection. Receiving
 function isMessengerResponse(response) {
     return isObject(response) && response["__webextMessenger"] === true;
 }
-function makeMessage(type, args, target) {
+function makeMessage(type, args, target, options) {
     return {
         __webextMessenger,
         type,
         args,
         target,
+        options,
     };
 }
 // Do not turn this into an `async` function; Notifications must turn `void`
@@ -25,20 +26,26 @@ function manageConnection(type, options, sendMessage) {
     });
 }
 async function manageMessage(type, sendMessage) {
-    const response = await pRetry(sendMessage, {
+    const response = await pRetry(async () => {
+        const response = await sendMessage();
+        if (!isMessengerResponse(response)) {
+            throw new MessengerError(`No handler registered for ${type} in the receiving end`);
+        }
+        return response;
+    }, {
         minTimeout: 100,
         factor: 1.3,
         maxRetryTime: 4000,
         onFailedAttempt(error) {
-            if (!String(error === null || error === void 0 ? void 0 : error.message).startsWith(errorNonExistingTarget)) {
+            if (error instanceof MessengerError ||
+                String(error.message).startsWith(errorNonExistingTarget)) {
+                debug(type, "will retry. Attempt", error.attemptNumber);
+            }
+            else {
                 throw error;
             }
-            debug(type, "will retry");
         },
     });
-    if (!isMessengerResponse(response)) {
-        throw new MessengerError(`No handler for ${type} was registered in the receiving end`);
-    }
     if ("error" in response) {
         debug(type, "↘️ replied with error", response.error);
         throw deserializeError(response.error);
@@ -47,6 +54,7 @@ async function manageMessage(type, sendMessage) {
     return response.value;
 }
 function messenger(type, options, target, ...args) {
+    // Message goes to extension page
     if ("page" in target) {
         if (target.page === "background" && isBackgroundPage()) {
             const handler = handlers.get(type);
@@ -58,7 +66,7 @@ function messenger(type, options, target, ...args) {
         }
         const sendMessage = async () => {
             debug(type, "↗️ sending message to runtime");
-            return browser.runtime.sendMessage(makeMessage(type, args));
+            return browser.runtime.sendMessage(makeMessage(type, args, target, options));
         };
         return manageConnection(type, options, sendMessage);
     }
@@ -66,7 +74,7 @@ function messenger(type, options, target, ...args) {
     if (!browser.tabs) {
         return manageConnection(type, options, async () => {
             debug(type, "↗️ sending message to runtime");
-            return browser.runtime.sendMessage(makeMessage(type, args, target));
+            return browser.runtime.sendMessage(makeMessage(type, args, target, options));
         });
     }
     // `frameId` must be specified. If missing, the message is sent to every frame
@@ -74,7 +82,7 @@ function messenger(type, options, target, ...args) {
     // 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), {
+        return browser.tabs.sendMessage(tabId, makeMessage(type, args, target, options), {
             frameId,
         });
     });

package/distribution/shared.d.ts

@@ -1,4 +1,11 @@
+import { JsonObject } from "type-fest";
 import { Method } from "./types.js";
+declare type ErrorObject = {
+    name?: string;
+    stack?: string;
+    message?: string;
+    code?: string;
+} & JsonObject;
 export declare const __webextMessenger = true;
 export declare function isObject(value: unknown): value is Record<string, unknown>;
 export declare class MessengerError extends Error {
@@ -7,3 +14,6 @@ export declare class MessengerError extends Error {
 export declare const handlers: Map<string, Method>;
 export declare const debug: (...args: any[]) => void;
 export declare const warn: (...args: any[]) => void;
+export declare function isErrorObject(error: unknown): error is ErrorObject;
+export declare function delay(milliseconds: number): Promise<void>;
+export {};

package/distribution/shared.js

@@ -17,3 +17,13 @@ export const handlers = new Map();
 // .bind preserves the call location in the console
 export const debug = console.debug.bind(console, "Messenger:");
 export const warn = console.warn.bind(console, "Messenger:");
+export function isErrorObject(error) {
+    var _a;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- This is a type guard function and it uses ?.
+    return typeof ((_a = error) === null || _a === void 0 ? void 0 : _a.message) === "string";
+}
+export async function delay(milliseconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}

package/distribution/thisTarget.d.ts

@@ -1,6 +1,10 @@
-import { Target, PageTarget, MessengerMeta } from "./types.js";
-declare type AnyTarget = Partial<Target & PageTarget>;
-export declare function getActionForMessage(target: AnyTarget): "respond" | "forward" | "ignore";
+import { MessengerMeta, Sender } from "./types.js";
+interface AnyTarget {
+    tabId?: number | "this";
+    frameId?: number;
+    page?: string;
+}
+export declare function getActionForMessage(from: Sender, { ...to }: AnyTarget): "respond" | "forward" | "ignore";
 export declare function nameThisTarget(): Promise<void>;
 declare function __getTabData(this: MessengerMeta): AnyTarget;
 declare global {

package/distribution/thisTarget.js

@@ -6,9 +6,10 @@ import { debug } from "./shared.js";
 // 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") {
+export function getActionForMessage(from, { ...to } // Clone object because we're editing it
+) {
+    var _a;
+    if (to.page === "any") {
         return "respond";
     }
     // Content scripts only receive messages that are meant for them. In the future
@@ -17,7 +18,7 @@ export function getActionForMessage(target) {
         return "respond";
     }
     // We're in an extension page, but the target is not one.
-    if (!("page" in target)) {
+    if (!to.page) {
         return "forward";
     }
     if (!thisTarget) {
@@ -25,18 +26,24 @@ export function getActionForMessage(target) {
         // If this *was* the target, then probably no one else answered
         return "ignore";
     }
+    // If requests "this" tab, then set it to allow the next condition
+    if (to.tabId === "this" && thisTarget.tabId === ((_a = from.tab) === null || _a === void 0 ? void 0 : _a.id)) {
+        to.tabId = thisTarget.tabId;
+    }
     // Every `target` key must match `thisTarget`
-    const isThisTarget = Object.entries(target).every(
+    const isThisTarget = Object.entries(to).every(
     // @ts-expect-error Optional properties
     ([key, value]) => thisTarget[key] === value);
     if (!isThisTarget) {
-        debug("The message’s target is", target, "but this is", thisTarget);
+        debug("The message’s target is", to, "but this is", thisTarget);
     }
     return isThisTarget ? "respond" : "ignore";
 }
+let nameRequested = false;
 export async function nameThisTarget() {
     // Same as above: CS receives messages correctly
-    if (!thisTarget && !isContentScript()) {
+    if (!nameRequested && !thisTarget && !isContentScript()) {
+        nameRequested = true;
         thisTarget = await messenger("__getTabData", {}, { page: "any" });
         thisTarget.page = location.pathname;
     }
@@ -46,8 +53,9 @@ function __getTabData() {
     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() {
+    // Any context can handler this message
+    registerMethods({ __getTabData });
     if (isBackgroundPage()) {
         thisTarget = { page: "background" };
-        registerMethods({ __getTabData });
     }
 }

package/distribution/types.d.ts

@@ -6,13 +6,13 @@ declare global {
         _: Method;
     }
 }
-declare type WithTarget<Method> = Method extends (...args: infer PreviousArguments) => infer TReturnValue ? (target: Target, ...args: PreviousArguments) => TReturnValue : never;
+declare type WithTarget<Method> = Method extends (...args: infer PreviousArguments) => infer TReturnValue ? (target: Target | PageTarget, ...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 */
 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: Runtime.MessageSender[];
+    trace: Sender[];
 }
 declare type RawMessengerResponse = {
     value: unknown;
@@ -31,15 +31,16 @@ export interface Options {
      * @default false
      */
     isNotification?: boolean;
+    trace?: Sender[];
 }
 export declare type Message<LocalArguments extends Arguments = Arguments> = {
     type: keyof MessengerMethods;
     args: LocalArguments;
-    /** If the message is being sent to an intermediary receiver, also set the target */
-    target?: Target;
+    target: Target | PageTarget;
     /** If the message is being sent to an intermediary receiver, also set the options */
-    options?: Target;
+    options?: Options;
 };
+export declare type Sender = Runtime.MessageSender;
 export declare type MessengerMessage = Message & {
     /** Guarantees that a message is meant to be handled by this library */
     __webextMessenger: true;
@@ -49,7 +50,7 @@ export interface Target {
     frameId?: number;
 }
 export interface PageTarget {
-    tabId?: number;
+    tabId?: number | "this";
     page: string;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webext-messenger",
-  "version": "0.14.1",
+  "version": "0.15.0-3",
   "description": "Browser Extension component messaging framework",
   "keywords": [],
   "repository": "pixiebrix/webext-messenger",
@@ -13,7 +13,8 @@
     "./source/sender.js": "./source/sender.ts",
     "./source/receiver.js": "./source/receiver.ts",
     "./source/types.js": "./source/types.ts",
-    "./source/shared.js": "./source/shared.ts"
+    "./source/shared.js": "./source/shared.ts",
+    "./source/thisTarget.js": "./source/thisTarget.ts"
   },
   "scripts": {
     "build": "tsc",
@@ -127,7 +128,8 @@
     "npm-run-all": "^4.1.5",
     "parcel": "^2.0.1",
     "tape": "^5.3.2",
-    "typescript": "^4.5.2"
+    "typescript": "^4.5.2",
+    "webext-content-scripts": "^0.10.1"
   },
   "targets": {
     "main": false,

package/distribution/api.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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/namedTargets.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="firefox-webext-browser" />
-import { NamedTarget, Target, MessengerMeta } from "./types.js";
-declare global {
-    interface MessengerMethods {
-        __webextMessengerTargetRegistration: typeof _registerTarget;
-    }
-}
-export declare function resolveNamedTarget(target: NamedTarget, sender?: browser.runtime.MessageSender): Target;
-export declare const targets: Map<string, Target>;
-/** Register the current context so that it can be targeted with a name */
-export declare const registerTarget: (name: string) => Promise<void>;
-declare function _registerTarget(this: MessengerMeta, name: string): Promise<void>;
-export declare function initTargets(): void;
-export {};

package/distribution/namedTargets.js

@@ -1,40 +0,0 @@
-import { isBackgroundPage } from "webext-detect-page";
-import { errorNonExistingTarget, getMethod } from "./sender.js";
-import { registerMethods } from "./receiver.js";
-export function resolveNamedTarget(target, sender) {
-    var _a;
-    if (!isBackgroundPage()) {
-        throw new Error("Named targets can only be resolved in the background page");
-    }
-    const { name, tabId = (_a = sender === null || sender === void 0 ? void 0 : sender.tab) === null || _a === void 0 ? void 0 : _a.id, // If not specified, try to use the sender’s
-     } = target;
-    if (typeof tabId === "undefined") {
-        throw new TypeError(`${errorNonExistingTarget} The tab ID was not specified nor it was automatically determinable.`);
-    }
-    const resolvedTarget = targets.get(`${tabId}%${name}`);
-    if (!resolvedTarget) {
-        throw new Error(`${errorNonExistingTarget} Target named ${name} not registered for tab ${tabId}.`);
-    }
-    return resolvedTarget;
-}
-// TODO: Remove targets after tab closes to avoid "memory leaks"
-export const targets = new Map();
-/** Register the current context so that it can be targeted with a name */
-export const registerTarget = getMethod("__webextMessengerTargetRegistration");
-async function _registerTarget(name) {
-    const sender = this.trace[0];
-    const tabId = sender.tab.id;
-    const { frameId } = sender;
-    targets.set(`${tabId}%${name}`, {
-        tabId,
-        frameId,
-    });
-    console.debug(`Messenger: Target "${name}" registered for tab ${tabId}`);
-}
-export function initTargets() {
-    if (isBackgroundPage()) {
-        registerMethods({
-            __webextMessengerTargetRegistration: _registerTarget,
-        });
-    }
-}