webext-messenger 0.22.0-5 → 0.22.0

package/distribution/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./receiver.js";
 export * from "./sender.js";
 export * from "./types.js";
-export { getThisTarget, getTopLevelFrame } from "./thisTarget.js";
+export { getThisFrame, getTopLevelFrame } from "./thisTarget.js";

package/distribution/index.js

@@ -2,6 +2,6 @@
 export * from "./receiver.js";
 export * from "./sender.js";
 export * from "./types.js";
-export { getThisTarget, getTopLevelFrame } from "./thisTarget.js";
+export { getThisFrame, getTopLevelFrame } from "./thisTarget.js";
 import { initPrivateApi } from "./thisTarget.js";
 initPrivateApi();

package/distribution/shared.d.ts

@@ -1,5 +1,5 @@
 import { type JsonObject } from "type-fest";
-declare type ErrorObject = {
+type ErrorObject = {
     name?: string;
     stack?: string;
     message?: string;

package/distribution/thisTarget.d.ts

@@ -1,6 +1,6 @@
-import { type AnyTarget, type KnownTarget, type TopLevelFrame, type Message, type MessengerMeta, type Sender } from "./types.js";
+import { type AnyTarget, type TopLevelFrame, type Message, type MessengerMeta, type Sender, type FrameTarget } from "./types.js";
 export declare function getActionForMessage(from: Sender, message: Message): "respond" | "forward" | "ignore";
 export declare function __getTabData(this: MessengerMeta): AnyTarget;
-export declare function getThisTarget(): Promise<KnownTarget>;
+export declare function getThisFrame(): Promise<FrameTarget>;
 export declare function getTopLevelFrame(): Promise<TopLevelFrame>;
 export declare function initPrivateApi(): void;

package/distribution/thisTarget.js

@@ -29,16 +29,17 @@ const thisTarget = isBackground()
     ? { page: "background" }
     : {
         get page() {
-            return location.pathname + location.search;
+            // Extension pages have relative URLs to simplify comparison
+            const origin = location.protocol.startsWith("http")
+                ? location.origin
+                : "";
+            // Don't use the hash
+            return origin + location.pathname + location.search;
         },
     };
 let tabDataStatus = 
 // The background page doesn't have a tab
-isBackground() ||
-    // Content scripts don't use named targets yet
-    isContentScript()
-    ? "not-needed"
-    : "needed";
+isBackground() ? "not-needed" : "needed";
 function compareTargets(to, thisTarget) {
     for (const [key, value] of Object.entries(to)) {
         if (thisTarget[key] === value) {
@@ -112,15 +113,17 @@ const storeTabData = once(async () => {
 export function __getTabData() {
     return { tabId: this.trace[0]?.tab?.id, frameId: this.trace[0]?.frameId };
 }
-export async function getThisTarget() {
+export async function getThisFrame() {
     await storeTabData(); // It should already have been called by we still need to await it
-    return thisTarget;
+    const { tabId, frameId } = thisTarget;
+    if (typeof tabId !== "number" || typeof frameId !== "number") {
+        throw new TypeError("This target is not in a frame");
+    }
+    // Rebuild object to return exactly these two properties and nothing more
+    return { tabId, frameId };
 }
 export async function getTopLevelFrame() {
-    const { tabId } = await getThisTarget();
-    if (typeof tabId !== "number") {
-        throw new TypeError("This target is not in a tab");
-    }
+    const { tabId } = await getThisFrame();
     return {
         tabId,
         frameId: 0,

package/distribution/types.d.ts

@@ -1,72 +1,81 @@
 import { type Runtime } from "webextension-polyfill";
 import { type Asyncify, type ValueOf } from "type-fest";
 import { type ErrorObject } from "serialize-error";
+/**
+ * @file Target types are a bit overlapping. That's because some are "request" targets
+ * and some are "known" targets. The difference is that you could "request" `{tabId: 1}`, but you "know" that a specific target is exactly `{tabId: 1, frameId: 5}`
+ * TODO: Cleanup, clarify, deduplicate Target types
+ */
 declare global {
     interface MessengerMethods {
         _: Method;
     }
 }
-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;
+type WithTarget<Method> = Method extends (...args: infer PreviousArguments) => infer TReturnValue ? (target: Target | PageTarget, ...args: PreviousArguments) => TReturnValue : never;
+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 declare type MessengerMeta = {
+export type PublicMethod<Method extends ValueOf<MessengerMethods>> = Asyncify<ActuallyOmitThisParameter<Method>>;
+export type PublicMethodWithTarget<Method extends ValueOf<MessengerMethods>> = WithTarget<PublicMethod<Method>>;
+export interface MessengerMeta {
     trace: Sender[];
-};
-declare type RawMessengerResponse = {
+}
+type RawMessengerResponse = {
     value: unknown;
 } | {
     error: ErrorObject;
 };
-export declare type MessengerResponse = RawMessengerResponse & {
+export type MessengerResponse = RawMessengerResponse & {
     /** Guarantees that the message was handled by this library */
     __webextMessenger: true;
 };
-declare type Arguments = any[];
-export declare type Method = (this: MessengerMeta, ...args: Arguments) => Promise<unknown>;
-export declare type Options = {
+type Arguments = any[];
+export type Method = (this: MessengerMeta, ...args: Arguments) => Promise<unknown>;
+export interface Options {
     /**
      * "Notifications" won't await the response, return values, attempt retries, nor throw errors
      * @default false
      */
     isNotification?: boolean;
     trace?: Sender[];
-};
-export declare type Message<LocalArguments extends Arguments = Arguments> = {
+}
+export type Message<LocalArguments extends Arguments = Arguments> = {
     type: keyof MessengerMethods;
     args: LocalArguments;
     target: Target | PageTarget;
     /** If the message is being sent to an intermediary receiver, also set the options */
     options?: Options;
 };
-export declare type Sender = Runtime.MessageSender & {
+export type Sender = Runtime.MessageSender & {
     origin?: string;
 };
-export declare type MessengerMessage = Message & {
+export type MessengerMessage = Message & {
     /** Guarantees that a message is meant to be handled by this library */
     __webextMessenger: true;
 };
-export declare type AnyTarget = {
+export interface AnyTarget {
     tabId?: number | "this";
     frameId?: number;
     page?: string;
-};
-export declare type TopLevelFrame = {
+}
+export interface TopLevelFrame {
     tabId: number;
     frameId: 0;
-};
-export declare type KnownTarget = {
+}
+export interface FrameTarget {
+    tabId: number;
+    frameId: number;
+}
+export interface KnownTarget {
     tabId?: number;
     frameId?: number;
     page: string;
-};
-export declare type Target = {
+}
+export interface Target {
     tabId: number;
     frameId?: number;
-};
-export declare type PageTarget = {
+}
+export interface PageTarget {
     tabId?: number | "this";
     page: string;
-};
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webext-messenger",
-  "version": "0.22.0-5",
+  "version": "0.22.0",
   "description": "Browser Extension component messaging framework",
   "keywords": [],
   "repository": "pixiebrix/webext-messenger",