webext-messenger 0.35.0 → 0.36.0

package/distribution/sender.js

@@ -1,11 +1,9 @@
-import { isExtensionContext } from "webext-detect";
+import { isBackground, isExtensionContext } from "webext-detect";
 import { deserializeError } from "serialize-error";
 import { isObject, MessengerError, ExtensionNotFoundError, __webextMessenger, } from "./shared.js";
 import { log } from "./logging.js";
 import { handlers } from "./handlers.js";
 import { events } from "./events.js";
-import { compareTargets } from "./targetLogic.js";
-import { thisTarget } from "./thisTarget.js";
 const _errorNonExistingTarget = "Could not establish connection. Receiving end does not exist.";
 const _errorTargetClosedEarly = "A listener indicated an asynchronous response by returning true, but the message channel closed before a response was received";
 export const errorTargetClosedEarly = "The target was closed before receiving a response";
@@ -186,17 +184,16 @@ function messenger(type, options, target, ...args) {
         };
         return manageConnection(type, options, target, sendMessage);
     }
-    // Use local methods if the target matches the current context
-    if (compareTargets(target, thisTarget)) {
-        const handler = handlers.get(type);
-        if (handler) {
-            log.warn(type, seq, "is being handled locally");
-            return handler.apply({ trace: [] }, args);
-        }
-        throw new MessengerError("No handler registered locally for " + type);
-    }
     // Message goes to extension page
     if ("page" in target) {
+        if (target.page === "background" && isBackground()) {
+            const handler = handlers.get(type);
+            if (handler) {
+                log.warn(type, seq, "is being handled locally");
+                return handler.apply({ trace: [] }, args);
+            }
+            throw new MessengerError("No handler registered locally for " + type);
+        }
         const sendMessage = async (attemptCount) => {
             log.debug(type, seq, "↗️ sending message to runtime", attemptLog(attemptCount));
             return chrome.runtime.sendMessage(makeMessage(type, args, target, options));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webext-messenger",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "Browser Extension component messaging framework",
   "keywords": [],
   "repository": "pixiebrix/webext-messenger",
@@ -27,18 +27,18 @@
     "watch": "tsc --watch"
   },
   "dependencies": {
-    "one-event": "^4.3.0",
-    "serialize-error": "^12.0.0",
-    "type-fest": "^5.0.1",
+    "one-event": "^4.4.0",
+    "serialize-error": "^13.0.1",
+    "type-fest": "^5.7.0",
     "webext-detect": "^5.3.2"
   },
   "@parcel/resolver-default": {
     "packageExports": true
   },
   "devDependencies": {
-    "@parcel/config-webextension": "^2.16.0",
-    "@sindresorhus/tsconfig": "^8.0.1",
-    "@types/chrome": "^0.1.22",
+    "@parcel/config-webextension": "^2.16.3",
+    "@sindresorhus/tsconfig": "^8.1.0",
+    "@types/chrome": "^0.2.1",
     "@types/tape": "^5.8.1",
     "buffer": "^6.0.3",
     "eslint": "^8.57.0",
@@ -49,9 +49,9 @@
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
     "stream-browserify": "^3.0.0",
-    "tape": "^5.9.0",
+    "tape": "^5.10.2",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.9"
   },
   "targets": {
     "main": false,

package/distribution/sender.test.d.ts

@@ -1,6 +0,0 @@
-declare global {
-    interface MessengerMethods {
-        testMethod: () => Promise<string>;
-    }
-}
-export {};

package/distribution/sender.test.js

@@ -1,160 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument, @typescript-eslint/naming-convention */
-import { describe, test, expect, vi, beforeEach } from "vitest";
-import { handlers } from "./handlers.js";
-import * as thisTargetModule from "./thisTarget.js";
-// Mock dependencies
-vi.mock("webext-detect", () => ({
-    isBackground: vi.fn(() => false),
-    isExtensionContext: vi.fn(() => true),
-    isOffscreenDocument: vi.fn(() => false),
-    isContentScript: vi.fn(() => true),
-}));
-vi.mock("./logging.js", () => ({
-    log: {
-        debug: vi.fn(),
-        warn: vi.fn(),
-    },
-}));
-vi.mock("./events.js", () => ({
-    events: {
-        dispatchEvent: vi.fn(),
-    },
-}));
-// Mock chrome APIs - simulate content script environment (no chrome.tabs)
-globalThis.chrome = {
-    runtime: {
-        id: "test-extension-id",
-        sendMessage: vi.fn(),
-    },
-    // Note: chrome.tabs is undefined in content scripts
-};
-describe("messenger with tab targets and local methods", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        handlers.clear();
-    });
-    test("should use local method when targeting same tab and frame", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to same tab and frame
-        const result = await messenger("testMethod", {}, { tabId: 1, frameId: 0 });
-        // Verify: Handler was called locally
-        expect(mockHandler).toHaveBeenCalledOnce();
-        expect(mockHandler).toHaveBeenCalledWith();
-        expect(result).toBe("local result");
-        // Verify: No message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).not.toHaveBeenCalled();
-    });
-    test("should send message when targeting different tab", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler (should not be used)
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Mock chrome.runtime.sendMessage to return a messenger response
-        vi.mocked(chrome.runtime.sendMessage).mockResolvedValue({
-            __webextMessenger: true,
-            value: "remote result",
-        });
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to different tab
-        const result = await messenger("testMethod", {}, { tabId: 2, frameId: 0 });
-        // Verify: Message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).toHaveBeenCalledOnce();
-        expect(result).toBe("remote result");
-        // Verify: Local handler was not called
-        expect(mockHandler).not.toHaveBeenCalled();
-    });
-    test("should send message when targeting different frame in same tab", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler (should not be used)
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Mock chrome.runtime.sendMessage to return a messenger response
-        vi.mocked(chrome.runtime.sendMessage).mockResolvedValue({
-            __webextMessenger: true,
-            value: "remote result",
-        });
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to different frame in same tab
-        const result = await messenger("testMethod", {}, { tabId: 1, frameId: 1 });
-        // Verify: Message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).toHaveBeenCalledOnce();
-        expect(result).toBe("remote result");
-        // Verify: Local handler was not called
-        expect(mockHandler).not.toHaveBeenCalled();
-    });
-    test("should send message when targeting allFrames", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // Register a local handler (should not be used for allFrames)
-        const mockHandler = vi.fn(async () => "local result");
-        handlers.set("testMethod", mockHandler);
-        // Mock chrome.runtime.sendMessage to return a messenger response
-        vi.mocked(chrome.runtime.sendMessage).mockResolvedValue({
-            __webextMessenger: true,
-            value: "remote result",
-        });
-        // Import messenger after mocks are set up
-        const { messenger } = await import("./sender.js");
-        // Test: Send message to allFrames in same tab
-        const result = await messenger("testMethod", {}, { tabId: 1, frameId: "allFrames" });
-        // Verify: Message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).toHaveBeenCalledOnce();
-        expect(result).toBe("remote result");
-        // Verify: Local handler was not called
-        expect(mockHandler).not.toHaveBeenCalled();
-    });
-    test("should throw error when no local handler registered for same tab/frame", async () => {
-        // Setup: Set thisTarget to have tabId: 1, frameId: 0
-        const mockThisTarget = {
-            tabId: 1,
-            frameId: 0,
-            page: "test",
-        };
-        vi.spyOn(thisTargetModule, "thisTarget", "get").mockReturnValue(mockThisTarget);
-        // No handler registered
-        // Import messenger and MessengerError after mocks are set up
-        const { messenger } = await import("./sender.js");
-        const { MessengerError } = await import("./shared.js");
-        // Test: Send message to same tab and frame without handler
-        try {
-            await messenger("testMethod", {}, { tabId: 1, frameId: 0 });
-            expect.fail("Should have thrown an error");
-        }
-        catch (error) {
-            expect(error).toBeInstanceOf(MessengerError);
-            expect(error.message).toBe("No handler registered locally for testMethod");
-        }
-        // Verify: No message was sent via chrome.runtime.sendMessage
-        expect(chrome.runtime.sendMessage).not.toHaveBeenCalled();
-    });
-});