applesauce-core 0.0.0-next-20250511152752 → 0.0.0-next-20250526151506

package/dist/__tests__/exports.test.js

@@ -10,7 +10,18 @@ describe("exports", () => {
         "Helpers",
         "Queries",
         "QueryStore",
+        "TimeoutError",
+        "defined",
+        "firstValueFrom",
+        "getObservableValue",
+        "lastValueFrom",
+        "listenLatestUpdates",
         "logger",
+        "mapEventsToStore",
+        "mapEventsToTimeline",
+        "simpleTimeout",
+        "watchEventUpdates",
+        "withImmediateValueOrDefault",
       ]
     `);
     });

package/dist/event-store/__tests__/event-store.test.js

@@ -98,6 +98,12 @@ describe("add", () => {
         expect(eventStore.getEvent(newEvent.id)).toBeDefined();
         expect(eventStore.getReplaceable(event.kind, event.pubkey, "test")).toBe(newEvent);
     });
+    it("should return null when event is invalid and there isn't an existing event", () => {
+        const verifyEvent = vi.fn().mockReturnValue(false);
+        eventStore.verifyEvent = verifyEvent;
+        expect(eventStore.add(profile)).toBeNull();
+        expect(verifyEvent).toHaveBeenCalledWith(profile);
+    });
 });
 describe("inserts", () => {
     it("should emit newer replaceable events", () => {

package/dist/event-store/database.d.ts

@@ -23,7 +23,7 @@ export declare class Database {
     /** A stream of events removed from the database */
     removed: Subject<import("nostr-tools").Event>;
     /** A method thats called before a new event is inserted */
-    onBeforeInsert?: (event: NostrEvent) => void;
+    onBeforeInsert?: (event: NostrEvent) => boolean;
     get size(): number;
     protected claims: WeakMap<import("nostr-tools").Event, any>;
     /** Index helper methods */
@@ -41,9 +41,9 @@ export declare class Database {
     /** Gets an array of replaceable events */
     getReplaceable(kind: number, pubkey: string, d?: string): NostrEvent[] | undefined;
     /** Inserts an event into the database and notifies all subscriptions */
-    addEvent(event: NostrEvent): NostrEvent;
+    addEvent(event: NostrEvent): NostrEvent | null;
     /** Inserts and event into the database and notifies all subscriptions that the event has updated */
-    updateEvent(event: NostrEvent): NostrEvent;
+    updateEvent(event: NostrEvent): boolean;
     /** Removes an event from the database and notifies all subscriptions */
     removeEvent(eventOrId: string | NostrEvent): boolean;
     /** Sets the claim on the event and touches it */

package/dist/event-store/database.js

@@ -86,7 +86,9 @@ export class Database {
         const current = this.events.get(id);
         if (current)
             return current;
-        this.onBeforeInsert?.(event);
+        // Ignore events if before insert returns false
+        if (this.onBeforeInsert?.(event) === false)
+            return null;
         this.events.set(id, event);
         this.getKindIndex(event.kind).add(event);
         this.getAuthorsIndex(event.pubkey).add(event);
@@ -115,8 +117,9 @@ export class Database {
     /** Inserts and event into the database and notifies all subscriptions that the event has updated */
     updateEvent(event) {
         const inserted = this.addEvent(event);
-        this.updated.next(inserted);
-        return inserted;
+        if (inserted)
+            this.updated.next(inserted);
+        return inserted !== null;
     }
     /** Removes an event from the database and notifies all subscriptions */
     removeEvent(eventOrId) {

package/dist/event-store/event-store.d.ts

@@ -7,7 +7,10 @@ export declare class EventStore implements IEventStore {
     database: Database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
-    /** A method used to verify new events before added them */
+    /**
+     * A method used to verify new events before added them
+     * @returns true if the event is valid, false if it should be ignored
+     */
     verifyEvent?: (event: NostrEvent) => boolean;
     /** A stream of new events added to the store */
     inserts: Observable<NostrEvent>;
@@ -23,20 +26,21 @@ export declare class EventStore implements IEventStore {
     /** Copies important metadata from and identical event to another */
     static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
     /**
-     * Adds an event to the database and update subscriptions
-     * @throws
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
      */
-    add(event: NostrEvent, fromRelay?: string): NostrEvent;
+    add(event: NostrEvent, fromRelay?: string): NostrEvent | null;
     /** Removes an event from the database and updates subscriptions */
     remove(event: string | NostrEvent): boolean;
     /** Removes any event that is not being used by a subscription */
     prune(max?: number): number;
     /** Add an event to the store and notifies all subscribes it has updated */
-    update(event: NostrEvent): NostrEvent;
+    update(event: NostrEvent): boolean;
     /** Get all events matching a filter */
     getAll(filters: Filter | Filter[]): Set<NostrEvent>;
-    /** Check if the store has an event */
+    /** Check if the store has an event by id */
     hasEvent(id: string): boolean;
+    /** Get an event by id from the store */
     getEvent(id: string): NostrEvent | undefined;
     /** Check if the store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;

package/dist/event-store/event-store.js

@@ -18,7 +18,10 @@ export class EventStore {
     database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
-    /** A method used to verify new events before added them */
+    /**
+     * A method used to verify new events before added them
+     * @returns true if the event is valid, false if it should be ignored
+     */
     verifyEvent;
     /** A stream of new events added to the store */
     inserts;
@@ -28,10 +31,13 @@ export class EventStore {
     removes;
     constructor() {
         this.database = new Database();
+        // verify events before they are added to the database
         this.database.onBeforeInsert = (event) => {
-            // reject events that are invalid
+            // Ignore events that are invalid
             if (this.verifyEvent && this.verifyEvent(event) === false)
-                throw new Error("Invalid event");
+                return false;
+            else
+                return true;
         };
         // when events are added to the database, add the symbol
         this.database.inserted.subscribe((event) => {
@@ -100,8 +106,8 @@ export class EventStore {
             Reflect.set(dest, FromCacheSymbol, fromCache);
     }
     /**
-     * Adds an event to the database and update subscriptions
-     * @throws
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
      */
     add(event, fromRelay) {
         if (event.kind === kinds.EventDeletion)
@@ -130,6 +136,9 @@ export class EventStore {
         }
         // Insert event into database
         const inserted = this.database.addEvent(event);
+        // If the event was ignored, return null
+        if (inserted === null)
+            return null;
         // Copy cached data if its a duplicate event
         if (event !== inserted)
             EventStore.mergeDuplicateEvent(event, inserted);
@@ -167,10 +176,11 @@ export class EventStore {
     getAll(filters) {
         return this.database.getEventsForFilters(Array.isArray(filters) ? filters : [filters]);
     }
-    /** Check if the store has an event */
+    /** Check if the store has an event by id */
     hasEvent(id) {
         return this.database.hasEvent(id);
     }
+    /** Get an event by id from the store */
     getEvent(id) {
         return this.database.getEvent(id);
     }

package/dist/event-store/interface.d.ts

@@ -27,7 +27,7 @@ export interface IStreamEventStore {
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
 }
 export interface IEventStore extends ISyncEventStore, IStreamEventStore {
-    add(event: NostrEvent, fromRelay?: string): NostrEvent;
+    add(event: NostrEvent, fromRelay?: string): NostrEvent | null;
     remove(event: string | NostrEvent): boolean;
-    update(event: NostrEvent): NostrEvent;
+    update(event: NostrEvent): void;
 }

package/dist/helpers/__tests__/app-handlers.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect } from "vitest";
+import { kinds } from "nostr-tools";
+import { getHandlerSupportedKinds, getHandlerName, getHandlerPicture, getHandlerDescription, getHandlerLinkTemplate, createHandlerProfileLink, createHandlerEventLink, createHandlerAddressLink, createHandlerLink, } from "../app-handlers.js";
+import { FakeUser } from "../../__tests__/fixtures.js";
+import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode } from "nostr-tools/nip19";
+// Create a fake user for testing
+const user = new FakeUser();
+// Mock handler event based on NIP-89 specification
+const mockHandler = user.event({
+    kind: kinds.Handlerinformation,
+    tags: [
+        ["d", "app-handler"],
+        ["k", "0"], // supports profiles
+        ["k", "1"], // supports notes
+        ["k", "30023"], // supports long-form content
+        ["web", "https://example.com/npub/<bech32>", "npub"],
+        ["web", "https://example.com/profile?nprofile=<bech32>", "nprofile"],
+        ["web", "https://example.com/note?id=<bech32>", "note"],
+        ["web", "https://example.com/event?nevent=<bech32>", "nevent"],
+        ["web", "https://example.com/article?naddr=<bech32>", "naddr"],
+        ["ios", "testhandler://<bech32>"],
+        ["android", "testhandler://<bech32>"],
+    ],
+    content: JSON.stringify({
+        name: "Test Handler",
+        display_name: "Test Handler App",
+        picture: "https://example.com/logo.png",
+        about: "A test handler for NIP-89",
+    }),
+});
+describe("getHandlerSupportedKinds", () => {
+    it("should return an array of supported kinds", () => {
+        expect(getHandlerSupportedKinds(mockHandler)).toEqual([0, 1, 30023]);
+    });
+    it("should return an empty array when no kinds are specified", () => {
+        const handlerWithoutKinds = user.event({
+            kind: kinds.Handlerinformation,
+            tags: mockHandler.tags.filter((tag) => tag[0] !== "k"),
+            content: mockHandler.content,
+        });
+        expect(getHandlerSupportedKinds(handlerWithoutKinds)).toEqual([]);
+    });
+});
+describe("getHandlerName", () => {
+    it("should return the handler name", () => {
+        expect(getHandlerName(mockHandler)).toBe("Test Handler App");
+    });
+});
+describe("getHandlerPicture", () => {
+    it("should return the handler picture", () => {
+        const picture = getHandlerPicture(mockHandler);
+        expect(picture).toBe("https://example.com/logo.png");
+    });
+    it("should return the fallback when no picture is available", () => {
+        const handlerWithoutPicture = user.event({
+            kind: kinds.Handlerinformation,
+            tags: mockHandler.tags,
+            content: JSON.stringify({
+                name: "Test Handler",
+                display_name: "Test Handler App",
+                about: "A test handler for NIP-89",
+            }),
+        });
+        const fallback = "https://fallback.com/default.png";
+        const picture = getHandlerPicture(handlerWithoutPicture, fallback);
+        expect(picture).toBe(fallback);
+    });
+});
+describe("getHandlerDescription", () => {
+    it("should return the handler description", () => {
+        const description = getHandlerDescription(mockHandler);
+        expect(description).toBe("A test handler for NIP-89");
+    });
+});
+describe("getHandlerLinkTemplate", () => {
+    it("should return the web link template for a specific type", () => {
+        const template = getHandlerLinkTemplate(mockHandler, "web", "npub");
+        expect(template).toBe("https://example.com/npub/<bech32>");
+    });
+    it("should return the ios link template", () => {
+        const template = getHandlerLinkTemplate(mockHandler, "ios");
+        expect(template).toBe("testhandler://<bech32>");
+    });
+    it("should return undefined when no template exists", () => {
+        // @ts-expect-error - unknown-type is not a valid type
+        const template = getHandlerLinkTemplate(mockHandler, "web", "unknown-type");
+        expect(template).toBeUndefined();
+    });
+});
+describe("createHandlerProfileLink", () => {
+    it("should create a profile link using nprofile format", () => {
+        const pointer = { pubkey: user.pubkey, relays: ["wss://relay.example.com"] };
+        expect(createHandlerProfileLink(mockHandler, pointer)).toEqual(`https://example.com/profile?nprofile=${nprofileEncode(pointer)}`);
+    });
+    it("should fallback to npub when nprofile template is not available", () => {
+        const handlerWithoutNprofile = user.event({
+            kind: kinds.Handlerinformation,
+            tags: mockHandler.tags.filter((tag) => !(tag[0] === "web" && tag[2] === "nprofile")),
+            content: mockHandler.content,
+        });
+        const pointer = { pubkey: user.pubkey, relays: ["wss://relay.example.com"] };
+        expect(createHandlerProfileLink(handlerWithoutNprofile, pointer)).toEqual(`https://example.com/npub/${npubEncode(pointer.pubkey)}`);
+    });
+    it("should use default when link type is not available", () => {
+        const handlerWithoutNprofile = user.event({
+            kind: kinds.Handlerinformation,
+            tags: [...mockHandler.tags.filter((tag) => !tag[2]), ["web", "https://example.com/<bech32>"]],
+            content: mockHandler.content,
+        });
+        const pointer = { pubkey: user.pubkey, relays: ["wss://relay.example.com"] };
+        expect(createHandlerProfileLink(handlerWithoutNprofile, pointer)).toEqual(`https://example.com/${nprofileEncode(pointer)}`);
+    });
+});
+describe("createHandlerEventLink", () => {
+    it("should create an event link using nevent format", () => {
+        const pointer = { id: user.event({ kind: 1111, content: "hello" }).id, relays: ["wss://relay.example.com"] };
+        expect(createHandlerEventLink(mockHandler, pointer)).toEqual(`https://example.com/event?nevent=${neventEncode(pointer)}`);
+    });
+    it("should fallback to note when nevent template is not available", () => {
+        const handlerWithoutNevent = user.event({
+            kind: kinds.Handlerinformation,
+            tags: mockHandler.tags.filter((tag) => tag[2] !== "nevent"),
+            content: mockHandler.content,
+        });
+        const pointer = { id: user.note("hello").id, relays: ["wss://relay.example.com"] };
+        expect(createHandlerEventLink(handlerWithoutNevent, pointer)).toEqual(`https://example.com/note?id=${noteEncode(pointer.id)}`);
+    });
+    it("should use default when link type is not available", () => {
+        const handlerWithoutNevent = user.event({
+            kind: kinds.Handlerinformation,
+            tags: [...mockHandler.tags.filter((tag) => !tag[2]), ["web", "https://example.com/<bech32>"]],
+            content: mockHandler.content,
+        });
+        const pointer = { id: user.note("hello").id, relays: ["wss://relay.example.com"] };
+        expect(createHandlerEventLink(handlerWithoutNevent, pointer)).toEqual(`https://example.com/${neventEncode(pointer)}`);
+    });
+});
+describe("createHandlerAddressLink", () => {
+    it("should create an address link using naddr format", () => {
+        const pointer = { identifier: "article1", pubkey: user.pubkey, kind: 30023, relays: ["wss://relay.example.com"] };
+        expect(createHandlerAddressLink(mockHandler, pointer)).toEqual(`https://example.com/article?naddr=${naddrEncode(pointer)}`);
+    });
+    it("should use default when link type is not available", () => {
+        const handlerWithoutNaddr = user.event({
+            kind: kinds.Handlerinformation,
+            tags: [...mockHandler.tags.filter((tag) => !tag[2]), ["web", "https://example.com/<bech32>"]],
+            content: mockHandler.content,
+        });
+        const pointer = { identifier: "article1", pubkey: user.pubkey, kind: 30023, relays: ["wss://relay.example.com"] };
+        expect(createHandlerAddressLink(handlerWithoutNaddr, pointer)).toEqual(`https://example.com/${naddrEncode(pointer)}`);
+    });
+});
+describe("createHandlerLink", () => {
+    it("should create a profile link for profile pointers", () => {
+        const pointer = { pubkey: user.pubkey, relays: ["wss://relay.example.com"] };
+        expect(createHandlerLink(mockHandler, pointer)).toEqual(`https://example.com/profile?nprofile=${nprofileEncode(pointer)}`);
+    });
+    it("should create an event link for event pointers", () => {
+        const pointer = { id: user.event({ kind: 1111, content: "hello" }).id, relays: ["wss://relay.example.com"] };
+        expect(createHandlerLink(mockHandler, pointer)).toEqual(`https://example.com/event?nevent=${neventEncode(pointer)}`);
+    });
+    it("should create an address link for address pointers", () => {
+        const pointer = { identifier: "article1", pubkey: user.pubkey, kind: 30023, relays: ["wss://relay.example.com"] };
+        expect(createHandlerLink(mockHandler, pointer)).toEqual(`https://example.com/article?naddr=${naddrEncode(pointer)}`);
+    });
+    it("should fallback to web platform when specified platform has no template", () => {
+        const handlerWithoutAndroid = user.event({
+            kind: kinds.Handlerinformation,
+            tags: mockHandler.tags.filter((tag) => tag[0] !== "android"),
+            content: mockHandler.content,
+        });
+        const pointer = { pubkey: user.pubkey, relays: ["wss://relay.example.com"] };
+        expect(createHandlerLink(handlerWithoutAndroid, pointer, "android")).toContain("https://example.com/profile?nprofile=");
+    });
+    it("should not fallback to web platform when webFallback is false", () => {
+        const handlerWithoutAndroid = user.event({
+            kind: kinds.Handlerinformation,
+            tags: mockHandler.tags.filter((tag) => tag[0] !== "android"),
+            content: mockHandler.content,
+        });
+        const pointer = { pubkey: user.pubkey, relays: ["wss://relay.example.com"] };
+        expect(createHandlerLink(handlerWithoutAndroid, pointer, "android", false)).toBeUndefined();
+    });
+});

package/dist/helpers/__tests__/emoji.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { getEmojiTag } from "../emoji.js";
+import { getEmojiTag, getReactionEmoji } from "../emoji.js";
 import { FakeUser } from "../../__tests__/fixtures.js";
 const user = new FakeUser();
 describe("getEmojiTag", () => {
@@ -13,3 +13,98 @@ describe("getEmojiTag", () => {
         expect(getEmojiTag(user.note("hello :custom:", { tags: [["emoji", "custom", "https://cdn.example.com/reaction1.png"]] }), "CustoM")).toEqual(["emoji", "custom", "https://cdn.example.com/reaction1.png"]);
     });
 });
+describe("getReactionEmoji", () => {
+    it("returns emoji object when content matches emoji tag", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "heart", "https://cdn.example.com/heart.png"]],
+            content: ":heart:",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toEqual({
+            shortcode: "heart",
+            url: "https://cdn.example.com/heart.png",
+        });
+    });
+    it("should return undefined when content is invalid shortcode", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "smile", "https://cdn.example.com/smile.png"]],
+            content: ":smile",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toBeUndefined();
+    });
+    it("handles double colon issue", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "smile", "https://cdn.example.com/smile.png"]],
+            content: "::smile::",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toEqual({
+            shortcode: "smile",
+            url: "https://cdn.example.com/smile.png",
+        });
+    });
+    it("trims whitespace from content", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "thumbsup", "https://cdn.example.com/thumbsup.png"]],
+            content: "  :thumbsup:  ",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toEqual({
+            shortcode: "thumbsup",
+            url: "https://cdn.example.com/thumbsup.png",
+        });
+    });
+    it("returns undefined when emoji tag is missing", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["p", "pub1"]],
+            content: ":missing:",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toBeUndefined();
+    });
+    it("returns undefined when content is empty", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "star", "https://cdn.example.com/star.png"]],
+            content: "",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toBeUndefined();
+    });
+    it("returns undefined when content is just colons", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "fire", "https://cdn.example.com/fire.png"]],
+            content: "::",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toBeUndefined();
+    });
+    it("returns undefined when emoji tag is invalid (missing url)", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "invalid"]],
+            content: ":invalid:",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toBeUndefined();
+    });
+    it("handles capital letters", () => {
+        const event = user.event({
+            kind: 7,
+            tags: [["emoji", "heart", "https://cdn.example.com/heart.png"]],
+            content: ":HEART:",
+        });
+        const result = getReactionEmoji(event);
+        expect(result).toEqual({
+            shortcode: "heart",
+            url: "https://cdn.example.com/heart.png",
+        });
+    });
+});

package/dist/helpers/__tests__/exports.test.js

@@ -37,11 +37,17 @@ describe("exports", () => {
         "NIP05_REGEX",
         "Nip10ThreadRefsSymbol",
         "PICTURE_POST_KIND",
+        "ParsedReportSymbol",
         "ProfileContentSymbol",
         "PublicContactsSymbol",
+        "ReactionAddressPointerSymbol",
+        "ReactionEventPointerSymbol",
         "ReplaceableIdentifierSymbol",
+        "ReportReason",
         "STREAM_EXT",
         "SeenRelaysSymbol",
+        "SharedAddressPointerSymbol",
+        "SharedEventPointerSymbol",
         "SharedEventSymbol",
         "UserStatusPointerSymbol",
         "VIDEO_EXT",
@@ -50,11 +56,16 @@ describe("exports", () => {
         "ZapFromSymbol",
         "ZapInvoiceSymbol",
         "ZapRequestSymbol",
+        "addRelayHintsToPointer",
         "addSeenRelay",
         "areBlossomServersEqual",
         "canHaveHiddenContent",
         "canHaveHiddenTags",
         "convertToUrl",
+        "createHandlerAddressLink",
+        "createHandlerEventLink",
+        "createHandlerLink",
+        "createHandlerProfileLink",
         "createMutedWordsRegExp",
         "createReplaceableAddress",
         "decodeGroupPointer",
@@ -62,6 +73,8 @@ describe("exports", () => {
         "decryptDirectMessage",
         "encodeDecodeResult",
         "encodeGroupPointer",
+        "ensureProtocol",
+        "ensureWebSocketURL",
         "fakeVerifyEvent",
         "getAddressPointerForEvent",
         "getAddressPointerFromATag",
@@ -82,6 +95,8 @@ describe("exports", () => {
         "getDeleteCoordinates",
         "getDeleteIds",
         "getDisplayName",
+        "getEmbededSharedEvent",
+        "getEmojiFromTags",
         "getEmojiTag",
         "getEmojis",
         "getEventPointerForEvent",
@@ -96,6 +111,12 @@ describe("exports", () => {
         "getGiftWrapEvent",
         "getGiftWrapSeal",
         "getGroupPointerFromGroupTag",
+        "getGroupPointerFromHTag",
+        "getHandlerDescription",
+        "getHandlerLinkTemplate",
+        "getHandlerName",
+        "getHandlerPicture",
+        "getHandlerSupportedKinds",
         "getHashtagTag",
         "getHiddenBookmarks",
         "getHiddenContacts",
@@ -118,8 +139,8 @@ describe("exports", () => {
         "getParentEventStore",
         "getPicturePostAttachments",
         "getPointerForEvent",
-        "getPointerFromTag",
         "getProfileContent",
+        "getProfilePicture",
         "getProfilePointerFromPTag",
         "getProfilePointersFromList",
         "getPubkeyFromDecodeResult",
@@ -127,13 +148,19 @@ describe("exports", () => {
         "getPublicContacts",
         "getPublicGroups",
         "getPublicMutedThings",
+        "getReactionAddressPointer",
+        "getReactionEmoji",
+        "getReactionEventPointer",
         "getRelaysFromContactsEvent",
         "getRelaysFromList",
         "getReplaceableAddress",
         "getReplaceableIdentifier",
         "getReplaceableUID",
+        "getReported",
         "getSeenRelays",
         "getSha256FromURL",
+        "getSharedAddressPointer",
+        "getSharedEventPointer",
         "getTagValue",
         "getURLFilename",
         "getUserStatusPointer",
@@ -145,6 +172,7 @@ describe("exports", () => {
         "getZapRequest",
         "getZapSender",
         "getZapSplits",
+        "groupMessageEvents",
         "hasHiddenContent",
         "hasHiddenTags",
         "interpretThreadTags",

package/dist/helpers/__tests__/groups.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import { decodeGroupPointer, encodeGroupPointer } from "../groups.js";
+describe("Group pointer utilities", () => {
+    describe("decodeGroupPointer", () => {
+        it("should decode a valid group pointer", () => {
+            const pointer = decodeGroupPointer("relay.example.com'group123");
+            expect(pointer).toEqual({
+                relay: "wss://relay.example.com",
+                id: "group123",
+            });
+        });
+        it("should add wss:// protocol if missing", () => {
+            const pointer = decodeGroupPointer("relay.example.com'group123");
+            expect(pointer.relay).toBe("wss://relay.example.com");
+        });
+        it("should preserve existing protocol if present", () => {
+            const pointer = decodeGroupPointer("wss://relay.example.com'group123");
+            expect(pointer.relay).toBe("wss://relay.example.com");
+            const wsPointer = decodeGroupPointer("ws://relay.example.com'group123");
+            expect(wsPointer.relay).toBe("ws://relay.example.com");
+        });
+        it("should handle default group id", () => {
+            const pointer = decodeGroupPointer("relay.example.com'");
+            expect(pointer).toEqual({
+                relay: "wss://relay.example.com",
+                id: "_",
+            });
+        });
+        it("should throw error if relay is missing", () => {
+            expect(() => decodeGroupPointer("'group123")).toThrow("Group pointer missing relay");
+        });
+    });
+    describe("encodeGroupPointer", () => {
+        it("should encode a valid group pointer", () => {
+            const pointer = {
+                relay: "wss://relay.example.com",
+                id: "group123",
+            };
+            expect(encodeGroupPointer(pointer)).toBe("relay.example.com'group123");
+        });
+        it("should strip protocol from relay", () => {
+            const pointer = {
+                relay: "wss://relay.example.com",
+                id: "group123",
+            };
+            expect(encodeGroupPointer(pointer)).toBe("relay.example.com'group123");
+            const wsPointer = {
+                relay: "ws://relay.example.com",
+                id: "group123",
+            };
+            expect(encodeGroupPointer(wsPointer)).toBe("relay.example.com'group123");
+        });
+        it("should handle invalid URLs by using the raw value", () => {
+            const pointer = {
+                relay: "invalid-url",
+                id: "group123",
+            };
+            expect(encodeGroupPointer(pointer)).toBe("invalid-url'group123");
+        });
+    });
+});