applesauce-core 0.0.0-next-20250312111321 → 0.0.0-next-20250312152821

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

@@ -1,8 +1,9 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { Database } from "./database.js";
+import { IEventStore } from "./interface.js";
 export declare const EventStoreSymbol: unique symbol;
-export declare class EventStore {
+export declare class EventStore implements IEventStore {
     database: Database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
@@ -50,7 +51,7 @@ export declare class EventStore {
     /** Returns an observable that completes when an event is removed */
     removed(id: string): Observable<never>;
     /** Creates an observable that emits when event is updated */
-    updated(id: string): Observable<NostrEvent>;
+    updated(event: string | NostrEvent): Observable<NostrEvent>;
     /** Creates an observable that subscribes to a single event */
     event(id: string): Observable<NostrEvent | undefined>;
     /** Creates an observable that subscribes to multiple events */

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

@@ -181,8 +181,8 @@ export class EventStore {
         mergeMap(() => EMPTY));
     }
     /** Creates an observable that emits when event is updated */
-    updated(id) {
-        return this.database.updated.pipe(filter((e) => e.id === id));
+    updated(event) {
+        return this.database.updated.pipe(filter((e) => e.id === event || e === event));
     }
     /** Creates an observable that subscribes to a single event */
     event(id) {
@@ -199,7 +199,7 @@ export class EventStore {
         // emit undefined when deleted
         this.removed(id).pipe(endWith(undefined))).pipe(
         // claim all events
-        claimEvents(this.database));
+        claimLatest(this.database));
     }
     /** Creates an observable that subscribes to multiple events */
     events(ids) {

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { kinds } from "nostr-tools";
+import { EventStore } from "./event-store.js";
+import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+let eventStore;
+beforeEach(() => {
+    eventStore = new EventStore();
+});
+const event = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+describe("add", () => {
+    it("should return original event in case of duplicates", () => {
+        const a = { ...event };
+        expect(eventStore.add(a)).toBe(a);
+        const b = { ...event };
+        expect(eventStore.add(b)).toBe(a);
+        const c = { ...event };
+        expect(eventStore.add(c)).toBe(a);
+    });
+    it("should merge seen relays on duplicate events", () => {
+        const a = { ...event };
+        addSeenRelay(a, "wss://relay.a.com");
+        eventStore.add(a);
+        const b = { ...event };
+        addSeenRelay(b, "wss://relay.b.com");
+        eventStore.add(b);
+        expect(eventStore.getEvent(event.id)).toBeDefined();
+        expect([...getSeenRelays(eventStore.getEvent(event.id))]).toEqual(expect.arrayContaining(["wss://relay.a.com", "wss://relay.b.com"]));
+    });
+    it("should ignore deleted events", () => {
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: event.created_at + 100,
+            pubkey: event.pubkey,
+            tags: [["e", event.id]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // add delete event first
+        eventStore.add(deleteEvent);
+        // now event should be ignored
+        eventStore.add(event);
+        expect(eventStore.getEvent(event.id)).toBeUndefined();
+    });
+});
+describe("verifyEvent", () => {
+    it("should be called for all events added", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        eventStore.add(event);
+        expect(verifyEvent).toHaveBeenCalledWith(event);
+    });
+    it("should not be called for duplicate events", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        const a = { ...event };
+        eventStore.add(a);
+        expect(verifyEvent).toHaveBeenCalledWith(a);
+        const b = { ...event };
+        eventStore.add(b);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+        const c = { ...event };
+        eventStore.add(c);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -1,2 +1,3 @@
 export * from "./event-store.js";
 export * from "./database.js";
+export * from "./interface.js";

package/dist/event-store/index.js

@@ -1,2 +1,3 @@
 export * from "./event-store.js";
 export * from "./database.js";
+export * from "./interface.js";

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

@@ -0,0 +1,27 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+export interface IEventStore {
+    updates: Observable<NostrEvent>;
+    add(event: NostrEvent, fromRelay?: string): NostrEvent;
+    remove(event: string | NostrEvent): boolean;
+    update(event: NostrEvent): NostrEvent;
+    hasEvent(id: string): boolean;
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
+    getEvent(id: string): NostrEvent | undefined;
+    getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
+    getAll(filters: Filter | Filter[]): Set<NostrEvent>;
+    getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    filters(filters: Filter | Filter[]): Observable<NostrEvent>;
+    updated(id: string | NostrEvent): Observable<NostrEvent>;
+    removed(id: string): Observable<never>;
+    event(id: string): Observable<NostrEvent | undefined>;
+    events(ids: string[]): Observable<Record<string, NostrEvent>>;
+    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Record<string, NostrEvent>>;
+    timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
+}

package/dist/event-store/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/helpers/cache.d.ts

@@ -1,5 +1,4 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
-export declare function getCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol): T | undefined;
-export declare function setCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, value: T): void;
+export declare function getCachedValue<T extends unknown>(event: any, symbol: symbol): T | undefined;
+export declare function setCachedValue<T extends unknown>(event: any, symbol: symbol, value: T): void;
 /** Internal method used to cache computed values on events */
-export declare function getOrComputeCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, compute: (event: NostrEvent | EventTemplate) => T): T;
+export declare function getOrComputeCachedValue<T extends unknown>(event: any, symbol: symbol, compute: () => T): T;

package/dist/helpers/cache.js

@@ -10,7 +10,7 @@ export function getOrComputeCachedValue(event, symbol, compute) {
         return Reflect.get(event, symbol);
     }
     else {
-        const value = compute(event);
+        const value = compute();
         Reflect.set(event, symbol, value);
         return value;
     }

package/dist/helpers/event.d.ts

@@ -1,5 +1,5 @@
-import { EventTemplate, NostrEvent, VerifiedEvent } from "nostr-tools";
-import { EventStore } from "../event-store/event-store.js";
+import { NostrEvent, VerifiedEvent } from "nostr-tools";
+import { IEventStore } from "../event-store/interface.js";
 export declare const EventUIDSymbol: unique symbol;
 export declare const EventIndexableTagsSymbol: unique symbol;
 export declare const FromCacheSymbol: unique symbol;
@@ -35,7 +35,12 @@ export declare function getIndexableTags(event: NostrEvent): Set<string>;
  * Returns the second index ( tag[1] ) of the first tag that matches the name
  * If the event has any hidden tags they will be searched first
  */
-export declare function getTagValue(event: NostrEvent | EventTemplate, name: string): string | undefined;
+export declare function getTagValue<T extends {
+    kind: number;
+    tags: string[][];
+    content: string;
+    pubkey: string;
+}>(event: T, name: string): string | undefined;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
 /** Marks an event as being from a cache */
@@ -43,7 +48,7 @@ export declare function markFromCache(event: NostrEvent): void;
 /** Returns if an event was from a cache */
 export declare function isFromCache(event: NostrEvent): boolean;
 /** Returns the EventStore of an event if its been added to one */
-export declare function getParentEventStore(event: NostrEvent): EventStore | undefined;
+export declare function getParentEventStore<T extends object>(event: T): IEventStore | undefined;
 /**
  * Returns the replaceable identifier for a replaceable event
  * @throws

package/dist/helpers/file-metadata.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/file-metadata.test.js

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { getFileMetadataFromImetaTag, parseFileMetadataTags } from "./file-metadata.js";
+describe("file metadata helpers", () => {
+    describe("parseFileMetadataTags", () => {
+        it("should parse a simple 1060 event", () => {
+            const tags = [
+                ["url", "https://image.nostr.build/30696696e57a2732d4e9f1b15ff4d4d4eaa64b759df6876863f436ff5d736eae.gif"],
+                ["ox", "30696696e57a2732d4e9f1b15ff4d4d4eaa64b759df6876863f436ff5d736eae"],
+                ["fallback", "https://media.tenor.com/wpvrkjn192gAAAAC/daenerys-targaryen.gif"],
+                ["x", "77fcf42b2b720babcdbe686eff67273d8a68862d74a2672db672bc48439a3ea5"],
+                ["m", "image/gif"],
+                ["dim", "360x306"],
+                ["bh", "L38zleNL00~W^kRj0L-p0KM_^kx]"],
+                ["blurhash", "L38zleNL00~W^kRj0L-p0KM_^kx]"],
+                [
+                    "thumb",
+                    "https://image.nostr.build/thumb/30696696e57a2732d4e9f1b15ff4d4d4eaa64b759df6876863f436ff5d736eae.gif",
+                ],
+                ["t", "gifbuddy"],
+                ["summary", "Khaleesi call dragons Daenerys Targaryen"],
+                ["alt", "a woman with blonde hair and a brooch on her shoulder"],
+                [
+                    "thumb",
+                    "https://media.tenor.com/wpvrkjn192gAAAAx/daenerys-targaryen.webp",
+                    "5d92423664fc15874b1d26c70a05a541ec09b5c438bf157977a87c8e64b31463",
+                ],
+                [
+                    "image",
+                    "https://media.tenor.com/wpvrkjn192gAAAAe/daenerys-targaryen.png",
+                    "5d92423664fc15874b1d26c70a05a541ec09b5c438bf157977a87c8e64b31463",
+                ],
+            ];
+            expect(parseFileMetadataTags(tags)).toEqual({
+                url: "https://image.nostr.build/30696696e57a2732d4e9f1b15ff4d4d4eaa64b759df6876863f436ff5d736eae.gif",
+                type: "image/gif",
+                dimensions: "360x306",
+                blurhash: "L38zleNL00~W^kRj0L-p0KM_^kx]",
+                sha256: "77fcf42b2b720babcdbe686eff67273d8a68862d74a2672db672bc48439a3ea5",
+                originalSha256: "30696696e57a2732d4e9f1b15ff4d4d4eaa64b759df6876863f436ff5d736eae",
+                thumbnail: "https://media.tenor.com/wpvrkjn192gAAAAx/daenerys-targaryen.webp",
+                image: "https://media.tenor.com/wpvrkjn192gAAAAe/daenerys-targaryen.png",
+                summary: "Khaleesi call dragons Daenerys Targaryen",
+                fallback: ["https://media.tenor.com/wpvrkjn192gAAAAC/daenerys-targaryen.gif"],
+                alt: "a woman with blonde hair and a brooch on her shoulder",
+            });
+        });
+    });
+    describe("getFileMetadataFromImetaTag", () => {
+        it("should parse simple imeta tag", () => {
+            expect(getFileMetadataFromImetaTag([
+                "imeta",
+                "url https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                "x 3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                "dim 1024x1024",
+                "m image/jpeg",
+                "blurhash ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+            ])).toEqual({
+                url: "https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                sha256: "3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                dimensions: "1024x1024",
+                type: "image/jpeg",
+                blurhash: "ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+            });
+        });
+        it("should parse thumbnail url", () => {
+            expect(getFileMetadataFromImetaTag([
+                "imeta",
+                "url https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                "x 3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                "dim 1024x1024",
+                "m image/jpeg",
+                "blurhash ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                "thumb https://exmaple.com/thumb.jpg",
+            ])).toEqual({
+                url: "https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                sha256: "3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                dimensions: "1024x1024",
+                type: "image/jpeg",
+                blurhash: "ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                thumbnail: "https://exmaple.com/thumb.jpg",
+            });
+        });
+        it("should parse multiple fallback urls", () => {
+            expect(getFileMetadataFromImetaTag([
+                "imeta",
+                "url https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                "x 3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                "dim 1024x1024",
+                "m image/jpeg",
+                "blurhash ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                "fallback https://exmaple.com/image2.jpg",
+                "fallback https://exmaple.com/image3.jpg",
+            ])).toEqual({
+                url: "https://blossom.primal.net/3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c.jpg",
+                sha256: "3f4dbf2797ac4e90b00bcfe2728e5c8367ed909c48230ac454cc325f1993646c",
+                dimensions: "1024x1024",
+                type: "image/jpeg",
+                blurhash: "ggH{Aws:RPWBRjaeay?^ozV@aeRjaej[$gt7kCofWVofkCrrofxuofa|ozbHx]s:tRofaet7ay",
+                fallback: ["https://exmaple.com/image2.jpg", "https://exmaple.com/image3.jpg"],
+            });
+        });
+    });
+});

package/dist/helpers/hidden-content.d.ts

@@ -1,4 +1,3 @@
-import { UnsignedEvent, type EventTemplate, type NostrEvent } from "nostr-tools";
 export declare const HiddenContentSymbol: unique symbol;
 export type HiddenContentSigner = {
     nip04?: {
@@ -17,14 +16,14 @@ export declare function setEventContentEncryptionMethod(kind: number, method: "n
 /** Checks if an event can have hidden content */
 export declare function canHaveHiddenContent(kind: number): boolean;
 /** Checks if an event has hidden content */
-export declare function hasHiddenContent(event: {
+export declare function hasHiddenContent<T extends {
     kind: number;
     content: string;
-}): boolean;
+}>(event: T): boolean;
 /** Returns the hidden tags for an event if they are unlocked */
-export declare function getHiddenContent(event: NostrEvent | EventTemplate): string | undefined;
+export declare function getHiddenContent<T extends object>(event: T): string | undefined;
 /** Checks if the hidden tags are locked */
-export declare function isHiddenContentLocked(event: NostrEvent | UnsignedEvent): boolean;
+export declare function isHiddenContentLocked<T extends object>(event: T): boolean;
 /** Returns either nip04 or nip44 encryption methods depending on event kind */
 export declare function getHiddenContentEncryptionMethods(kind: number, signer: HiddenContentSigner): {
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
@@ -33,14 +32,15 @@ export declare function getHiddenContentEncryptionMethods(kind: number, signer:
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
     decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
 };
+export type HiddenContentEvent = {
+    kind: number;
+    pubkey: string;
+    content: string;
+};
 /**
  * Unlocks the encrypted content in an event
  * @param event The event with content to decrypt
  * @param signer A signer to use to decrypt the tags
  * @throws
  */
-export declare function unlockHiddenContent(event: {
-    kind: number;
-    pubkey: string;
-    content: string;
-}, signer: HiddenContentSigner): Promise<string>;
+export declare function unlockHiddenContent<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string>;

package/dist/helpers/hidden-content.js

@@ -1,6 +1,6 @@
 import * as kinds from "nostr-tools/kinds";
 import { GROUPS_LIST_KIND } from "./groups.js";
-import { getParentEventStore } from "./event.js";
+import { getParentEventStore, isEvent } from "./event.js";
 export const HiddenContentSymbol = Symbol.for("hidden-content");
 /** Various event kinds that can have encrypted tags in their content and which encryption method they use */
 export const EventContentEncryptionMethod = {
@@ -46,7 +46,7 @@ export function getHiddenContent(event) {
 }
 /** Checks if the hidden tags are locked */
 export function isHiddenContentLocked(event) {
-    return getHiddenContent(event) === undefined;
+    return Reflect.has(event, HiddenContentSymbol) === false;
 }
 /** Returns either nip04 or nip44 encryption methods depending on event kind */
 export function getHiddenContentEncryptionMethods(kind, signer) {
@@ -69,8 +69,10 @@ export async function unlockHiddenContent(event, signer) {
     const plaintext = await encryption.decrypt(event.pubkey, event.content);
     Reflect.set(event, HiddenContentSymbol, plaintext);
     // if the event has been added to an event store, notify it
-    const eventStore = getParentEventStore(event);
-    if (eventStore)
-        eventStore.update(event);
+    if (isEvent(event)) {
+        const eventStore = getParentEventStore(event);
+        if (eventStore)
+            eventStore.update(event);
+    }
     return plaintext;
 }

package/dist/helpers/hidden-tags.d.ts

@@ -1,17 +1,18 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
-import { EventStore } from "../event-store/event-store.js";
-import { HiddenContentSigner } from "./hidden-content.js";
+import { HiddenContentEvent, HiddenContentSigner } from "./hidden-content.js";
 export declare const HiddenTagsSymbol: unique symbol;
 /** Checks if an event can have hidden tags */
 export declare function canHaveHiddenTags(kind: number): boolean;
 /** Checks if an event has hidden tags */
-export declare function hasHiddenTags(event: NostrEvent | EventTemplate): boolean;
+export declare function hasHiddenTags<T extends {
+    content: string;
+    kind: number;
+}>(event: T): boolean;
 /** Returns the hidden tags for an event if they are unlocked */
-export declare function getHiddenTags(event: NostrEvent | EventTemplate): string[][] | undefined;
+export declare function getHiddenTags<T extends object>(event: T): string[][] | undefined;
 /** Checks if the hidden tags are locked */
-export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
+export declare function isHiddenTagsLocked<T extends object>(event: T): boolean;
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export declare function getListEncryptionMethods(kind: number, signer: HiddenContentSigner): {
+export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): {
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
     decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
 } | {
@@ -25,14 +26,4 @@ export declare function getListEncryptionMethods(kind: number, signer: HiddenCon
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export declare function unlockHiddenTags<T extends {
-    kind: number;
-    pubkey: string;
-    content: string;
-}>(event: T, signer: HiddenContentSigner, store?: EventStore): Promise<string[][]>;
-/**
- * Override the hidden tags in an event
- * @deprecated use EventFactory to create draft events
- * @throws
- */
-export declare function overrideHiddenTags(event: NostrEvent, hidden: string[][], signer: HiddenContentSigner): Promise<EventTemplate>;
+export declare function unlockHiddenTags<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string[][]>;

package/dist/helpers/hidden-tags.js

@@ -1,6 +1,5 @@
-import { unixNow } from "./time.js";
-import { isEvent } from "./event.js";
-import { canHaveHiddenContent, getHiddenContentEncryptionMethods, unlockHiddenContent, } from "./hidden-content.js";
+import { canHaveHiddenContent, getHiddenContent, getHiddenContentEncryptionMethods, isHiddenContentLocked, unlockHiddenContent, } from "./hidden-content.js";
+import { getOrComputeCachedValue } from "./cache.js";
 export const HiddenTagsSymbol = Symbol.for("hidden-tags");
 /** Checks if an event can have hidden tags */
 export function canHaveHiddenTags(kind) {
@@ -12,14 +11,23 @@ export function hasHiddenTags(event) {
 }
 /** Returns the hidden tags for an event if they are unlocked */
 export function getHiddenTags(event) {
-    return Reflect.get(event, HiddenTagsSymbol);
+    if (isHiddenTagsLocked(event))
+        return undefined;
+    return getOrComputeCachedValue(event, HiddenTagsSymbol, () => {
+        const plaintext = getHiddenContent(event);
+        const parsed = JSON.parse(plaintext);
+        if (!Array.isArray(parsed))
+            throw new Error("Content is not an array of tags");
+        // Convert array to tags array string[][]
+        return parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
+    });
 }
 /** Checks if the hidden tags are locked */
 export function isHiddenTagsLocked(event) {
-    return hasHiddenTags(event) && getHiddenTags(event) === undefined;
+    return isHiddenContentLocked(event);
 }
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export function getListEncryptionMethods(kind, signer) {
+export function getHiddenTagsEncryptionMethods(kind, signer) {
     return getHiddenContentEncryptionMethods(kind, signer);
 }
 /**
@@ -29,34 +37,11 @@ export function getListEncryptionMethods(kind, signer) {
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export async function unlockHiddenTags(event, signer, store) {
+export async function unlockHiddenTags(event, signer) {
     if (!canHaveHiddenTags(event.kind))
         throw new Error("Event kind does not support hidden tags");
-    const plaintext = await unlockHiddenContent(event, signer);
-    const parsed = JSON.parse(plaintext);
-    if (!Array.isArray(parsed))
-        throw new Error("Content is not an array of tags");
-    // Convert array to tags array string[][]
-    const tags = parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
-    Reflect.set(event, HiddenTagsSymbol, tags);
-    if (store && isEvent(event))
-        store.update(event);
-    return tags;
-}
-/**
- * Override the hidden tags in an event
- * @deprecated use EventFactory to create draft events
- * @throws
- */
-export async function overrideHiddenTags(event, hidden, signer) {
-    if (!canHaveHiddenTags(event.kind))
-        throw new Error("Event kind does not support hidden tags");
-    const encryption = getListEncryptionMethods(event.kind, signer);
-    const ciphertext = await encryption.encrypt(event.pubkey, JSON.stringify(hidden));
-    return {
-        kind: event.kind,
-        content: ciphertext,
-        created_at: unixNow(),
-        tags: event.tags,
-    };
+    // unlock hidden content is needed
+    if (isHiddenContentLocked(event))
+        await unlockHiddenContent(event, signer);
+    return getHiddenTags(event);
 }

package/dist/helpers/hidden-tags.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/hidden-tags.test.js

@@ -0,0 +1,29 @@
+import { describe, beforeEach, it, expect } from "vitest";
+import { finalizeEvent, generateSecretKey, getPublicKey, kinds, nip04 } from "nostr-tools";
+import { getHiddenTags, unlockHiddenTags } from "./hidden-tags.js";
+import { unixNow } from "./time.js";
+const key = generateSecretKey();
+const pubkey = getPublicKey(key);
+const signer = {
+    nip04: {
+        encrypt: (pubkey, plaintext) => nip04.encrypt(key, pubkey, plaintext),
+        decrypt: (pubkey, ciphertext) => nip04.decrypt(key, pubkey, ciphertext),
+    },
+};
+describe("Private Lists", () => {
+    describe("unlockHiddenTags", () => {
+        let list;
+        beforeEach(async () => {
+            list = finalizeEvent({
+                kind: kinds.Mutelist,
+                created_at: unixNow(),
+                content: await nip04.encrypt(key, pubkey, JSON.stringify([["p", "npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr"]])),
+                tags: [],
+            }, key);
+        });
+        it("should unlock hidden tags", async () => {
+            await unlockHiddenTags(list, signer);
+            expect(getHiddenTags(list)).toEqual(expect.arrayContaining([["p", "npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr"]]));
+        });
+    });
+});

package/dist/helpers/mailboxes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/mailboxes.test.js

@@ -0,0 +1,81 @@
+import { describe, test, expect } from "vitest";
+import { getInboxes, getOutboxes } from "./mailboxes.js";
+const emptyEvent = {
+    kind: 10002,
+    content: "",
+    tags: [],
+    created_at: 0,
+    sig: "",
+    id: "",
+    pubkey: "",
+};
+describe("Mailboxes", () => {
+    describe("getInboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com"]],
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com,wss://inbox.org"]],
+            }))).toHaveLength(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/"]],
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
+        });
+        test("with marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/", "read"]],
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
+        });
+    });
+    describe("getOutboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com"]],
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com,wss://inbox.org"]],
+            }))).toHaveLength(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/"]],
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
+        });
+        test("with marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/", "write"]],
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
+        });
+    });
+});

package/dist/helpers/mutes.d.ts

@@ -7,6 +7,7 @@ export type Mutes = {
     hashtags: Set<string>;
     words: Set<string>;
 };
+/** Parses mute tags */
 export declare function parseMutedTags(tags: string[][]): Mutes;
 /** Returns muted things */
 export declare function getMutedThings(mute: NostrEvent): Mutes;