applesauce-core 1.2.0 → 2.1.0

package/dist/observable/simple-timeout.d.ts

@@ -1,4 +1,5 @@
 import { MonoTypeOperatorFunction } from "rxjs";
 export declare class TimeoutError extends Error {
 }
+/** Throws a {@link TimeoutError} if a value is not emitted within the timeout */
 export declare function simpleTimeout<T extends unknown>(first: number, message?: string): MonoTypeOperatorFunction<T>;

package/dist/observable/simple-timeout.js

@@ -1,6 +1,7 @@
 import { throwError, timeout } from "rxjs";
 export class TimeoutError extends Error {
 }
+/** Throws a {@link TimeoutError} if a value is not emitted within the timeout */
 export function simpleTimeout(first, message) {
     return timeout({ first, with: () => throwError(() => new TimeoutError(message ?? "Timeout")) });
 }

package/dist/observable/watch-event-updates.d.ts

@@ -0,0 +1,7 @@
+import { NostrEvent } from "nostr-tools";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IEventStoreStreams } from "../event-store/interface.js";
+/** Watches for any updates to the latest event and remits the event when updated */
+export declare function watchEventUpdates(eventStore: IEventStoreStreams): MonoTypeOperatorFunction<NostrEvent | undefined>;
+/** Watches for any updates to the latest array of events and remits the array of events when updated */
+export declare function watchEventsUpdates(eventStore: IEventStoreStreams): MonoTypeOperatorFunction<NostrEvent[]>;

package/dist/observable/watch-event-updates.js

@@ -0,0 +1,25 @@
+import { filter, map, merge, tap } from "rxjs";
+/** Watches for any updates to the latest event and remits the event when updated */
+export function watchEventUpdates(eventStore) {
+    return (source) => {
+        let latest;
+        return merge(
+        // Get the latest event
+        source.pipe(tap((value) => (latest = value))), 
+        // listen for updates
+        eventStore.update$.pipe(filter((e) => e.id === latest?.id)));
+    };
+}
+/** Watches for any updates to the latest array of events and remits the array of events when updated */
+export function watchEventsUpdates(eventStore) {
+    return (source) => {
+        let latest = [];
+        return merge(
+        // Get the latest event
+        source.pipe(tap((value) => (latest = value))), 
+        // listen for updates
+        eventStore.update$.pipe(filter((e) => latest.includes(e)), 
+        // re-emit the array of events
+        map(() => latest)));
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "1.2.0",
+  "version": "2.1.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -30,15 +30,15 @@
       "require": "./dist/helpers/*.js",
       "types": "./dist/helpers/*.d.ts"
     },
-    "./queries": {
-      "import": "./dist/queries/index.js",
-      "require": "./dist/queries/index.js",
-      "types": "./dist/queries/index.d.ts"
+    "./models": {
+      "import": "./dist/models/index.js",
+      "require": "./dist/models/index.js",
+      "types": "./dist/models/index.d.ts"
     },
-    "./queries/*": {
-      "import": "./dist/queries/*.js",
-      "require": "./dist/queries/*.js",
-      "types": "./dist/queries/*.d.ts"
+    "./models/*": {
+      "import": "./dist/models/*.js",
+      "require": "./dist/models/*.js",
+      "types": "./dist/models/*.d.ts"
     },
     "./observable": {
       "import": "./dist/observable/index.js",
@@ -50,11 +50,6 @@
       "require": "./dist/promise/index.js",
       "types": "./dist/promise/index.d.ts"
     },
-    "./query-store": {
-      "import": "./dist/query-store/index.js",
-      "require": "./dist/query-store/index.js",
-      "types": "./dist/query-store/index.d.ts"
-    },
     "./event-store": {
       "import": "./dist/event-store/index.js",
       "require": "./dist/event-store/index.js",
@@ -69,7 +64,7 @@
     "hash-sum": "^2.0.0",
     "light-bolt11-decoder": "^3.2.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.10.4",
+    "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
@@ -77,7 +72,7 @@
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
+    "vitest": "^3.2.3"
   },
   "funding": {
     "type": "lightning",

package/dist/__tests__/exports.test.d.ts

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

package/dist/__tests__/exports.test.js

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as exports from "../index.js";
-describe("exports", () => {
-    it("should export the expected functions", () => {
-        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
-      [
-        "Database",
-        "EventStore",
-        "EventStoreSymbol",
-        "Helpers",
-        "Queries",
-        "QueryStore",
-        "logger",
-      ]
-    `);
-    });
-});

package/dist/__tests__/fixtures.d.ts

@@ -1,8 +0,0 @@
-import type { NostrEvent } from "nostr-tools";
-export declare class FakeUser {
-    key: Uint8Array<ArrayBufferLike>;
-    pubkey: string;
-    event(data?: Partial<NostrEvent>): NostrEvent;
-    note(content?: string, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
-    profile(profile: any, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
-}

package/dist/__tests__/fixtures.js

@@ -1,20 +0,0 @@
-import { finalizeEvent, generateSecretKey, getPublicKey, kinds } from "nostr-tools";
-import { unixNow } from "../helpers/time.js";
-export class FakeUser {
-    key = generateSecretKey();
-    pubkey = getPublicKey(this.key);
-    event(data) {
-        return finalizeEvent({
-            kind: data?.kind ?? kinds.ShortTextNote,
-            content: data?.content || "",
-            created_at: data?.created_at ?? unixNow(),
-            tags: data?.tags || [],
-        }, this.key);
-    }
-    note(content = "Hello World", extra) {
-        return this.event({ kind: kinds.ShortTextNote, content, ...extra });
-    }
-    profile(profile, extra) {
-        return this.event({ kind: kinds.Metadata, content: JSON.stringify({ ...profile }), ...extra });
-    }
-}

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

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

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

@@ -1,354 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { kinds } from "nostr-tools";
-import { subscribeSpyTo } from "@hirez_io/observer-spy";
-import { EventStore } from "../event-store.js";
-import { addSeenRelay, getSeenRelays } from "../../helpers/relays.js";
-import { getEventUID } from "../../helpers/event.js";
-import { FakeUser } from "../../__tests__/fixtures.js";
-let eventStore;
-beforeEach(() => {
-    eventStore = new EventStore();
-});
-const user = new FakeUser();
-const profile = user.profile({ name: "fake user" });
-const note = user.note();
-describe("add", () => {
-    it("should return original event in case of duplicates", () => {
-        const a = { ...profile };
-        expect(eventStore.add(a)).toBe(a);
-        const b = { ...profile };
-        expect(eventStore.add(b)).toBe(a);
-        const c = { ...profile };
-        expect(eventStore.add(c)).toBe(a);
-    });
-    it("should merge seen relays on duplicate events", () => {
-        const a = { ...profile };
-        addSeenRelay(a, "wss://relay.a.com");
-        eventStore.add(a);
-        const b = { ...profile };
-        addSeenRelay(b, "wss://relay.b.com");
-        eventStore.add(b);
-        expect(eventStore.getEvent(profile.id)).toBeDefined();
-        expect([...getSeenRelays(eventStore.getEvent(profile.id))]).toEqual(expect.arrayContaining(["wss://relay.a.com", "wss://relay.b.com"]));
-    });
-    it("should ignore old deleted events but not newer ones", () => {
-        const deleteEvent = {
-            id: "delete event id",
-            kind: kinds.EventDeletion,
-            created_at: profile.created_at + 100,
-            pubkey: user.pubkey,
-            tags: [["e", profile.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(profile);
-        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
-        eventStore.add(newProfile);
-        expect(eventStore.getEvent(profile.id)).toBeUndefined();
-        expect(eventStore.getEvent(newProfile.id)).toBeDefined();
-    });
-    it("should remove profile events when delete event is added", () => {
-        // Add initial replaceable event
-        eventStore.add(profile);
-        expect(eventStore.getEvent(profile.id)).toBeDefined();
-        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
-        eventStore.add(newProfile);
-        const deleteEvent = {
-            id: "delete event id",
-            kind: kinds.EventDeletion,
-            created_at: profile.created_at + 100,
-            pubkey: user.pubkey,
-            tags: [["a", `${profile.kind}:${profile.pubkey}`]],
-            sig: "this should be ignored for the test",
-            content: "test",
-        };
-        // Add delete event with coordinate
-        eventStore.add(deleteEvent);
-        // Profile should be removed since delete event is newer
-        expect(eventStore.getEvent(profile.id)).toBeUndefined();
-        expect(eventStore.getEvent(newProfile.id)).toBeDefined();
-        expect(eventStore.getReplaceable(profile.kind, profile.pubkey)).toBe(newProfile);
-    });
-    it("should remove addressable replaceable events when delete event is added", () => {
-        // Add initial replaceable event
-        const event = user.event({ content: "test", kind: 30000, tags: [["d", "test"]] });
-        eventStore.add(event);
-        expect(eventStore.getEvent(event.id)).toBeDefined();
-        const newEvent = user.event({
-            ...event,
-            created_at: event.created_at + 500,
-        });
-        eventStore.add(newEvent);
-        const deleteEvent = {
-            id: "delete event id",
-            kind: kinds.EventDeletion,
-            created_at: event.created_at + 100,
-            pubkey: user.pubkey,
-            tags: [["a", `${event.kind}:${event.pubkey}:test`]],
-            sig: "this should be ignored for the test",
-            content: "test",
-        };
-        // Add delete event with coordinate
-        eventStore.add(deleteEvent);
-        // Profile should be removed since delete event is newer
-        expect(eventStore.getEvent(event.id)).toBeUndefined();
-        expect(eventStore.getEvent(newEvent.id)).toBeDefined();
-        expect(eventStore.getReplaceable(event.kind, event.pubkey, "test")).toBe(newEvent);
-    });
-});
-describe("inserts", () => {
-    it("should emit newer replaceable events", () => {
-        const spy = subscribeSpyTo(eventStore.inserts);
-        eventStore.add(profile);
-        const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 100 });
-        eventStore.add(newer);
-        expect(spy.getValues()).toEqual([profile, newer]);
-    });
-    it("should not emit when older replaceable event is added", () => {
-        const spy = subscribeSpyTo(eventStore.inserts);
-        eventStore.add(profile);
-        eventStore.add(user.profile({ name: "new name" }, { created_at: profile.created_at - 1000 }));
-        expect(spy.getValues()).toEqual([profile]);
-    });
-});
-describe("removes", () => {
-    it("should emit older replaceable events when the newest replaceable event is added", () => {
-        const spy = subscribeSpyTo(eventStore.removes);
-        eventStore.add(profile);
-        const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
-        eventStore.add(newer);
-        expect(spy.getValues()).toEqual([profile]);
-    });
-});
-describe("verifyEvent", () => {
-    it("should be called for all events added", () => {
-        const verifyEvent = vi.fn().mockReturnValue(true);
-        eventStore.verifyEvent = verifyEvent;
-        eventStore.add(profile);
-        expect(verifyEvent).toHaveBeenCalledWith(profile);
-    });
-    it("should not be called for duplicate events", () => {
-        const verifyEvent = vi.fn().mockReturnValue(true);
-        eventStore.verifyEvent = verifyEvent;
-        const a = { ...profile };
-        eventStore.add(a);
-        expect(verifyEvent).toHaveBeenCalledWith(a);
-        const b = { ...profile };
-        eventStore.add(b);
-        expect(verifyEvent).toHaveBeenCalledTimes(1);
-        const c = { ...profile };
-        eventStore.add(c);
-        expect(verifyEvent).toHaveBeenCalledTimes(1);
-    });
-});
-describe("removed", () => {
-    it("should complete when event is removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.removed(profile.id));
-        eventStore.remove(profile);
-        expect(spy.getValues()).toEqual([]);
-        expect(spy.receivedComplete()).toBe(true);
-    });
-});
-describe("event", () => {
-    it("should emit existing event", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.event(profile.id));
-        expect(spy.getValues()).toEqual([profile]);
-    });
-    it("should emit then event when its added", () => {
-        const spy = subscribeSpyTo(eventStore.event(profile.id));
-        expect(spy.getValues()).toEqual([]);
-        eventStore.add(profile);
-        expect(spy.getValues()).toEqual([profile]);
-    });
-    it("should emit undefined when event is removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.event(profile.id));
-        expect(spy.getValues()).toEqual([profile]);
-        eventStore.remove(profile);
-        expect(spy.getValues()).toEqual([profile, undefined]);
-    });
-    it("should emit new value if event is re-added", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.event(profile.id));
-        eventStore.remove(profile);
-        eventStore.add(profile);
-        expect(spy.getValues()).toEqual([profile, undefined, profile]);
-    });
-    it("should not complete when event is removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.event(profile.id));
-        eventStore.remove(profile);
-        expect(spy.receivedComplete()).toBe(false);
-    });
-    it("should not emit any values if there are no events", () => {
-        const spy = subscribeSpyTo(eventStore.event(profile.id));
-        expect(spy.receivedNext()).toBe(false);
-    });
-});
-describe("events", () => {
-    it("should emit existing events", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.events([profile.id]));
-        expect(spy.getValues()).toEqual([{ [profile.id]: profile }]);
-    });
-    it("should remove events when they are removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.events([profile.id]));
-        expect(spy.getValues()).toEqual([{ [profile.id]: profile }]);
-        eventStore.remove(profile);
-        expect(spy.getValues()).toEqual([{ [profile.id]: profile }, {}]);
-    });
-    it("should add events back if then are re-added", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.events([profile.id]));
-        eventStore.remove(profile);
-        eventStore.add(profile);
-        expect(spy.getValues()).toEqual([{ [profile.id]: profile }, {}, { [profile.id]: profile }]);
-    });
-    it("should not emit any values if there are no events", () => {
-        const spy = subscribeSpyTo(eventStore.events([profile.id]));
-        expect(spy.receivedNext()).toBe(false);
-    });
-});
-describe("replaceable", () => {
-    it("should not emit till there is an event", () => {
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        expect(spy.receivedNext()).toBe(false);
-    });
-    it("should emit existing events", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        expect(spy.getValues()).toEqual([profile]);
-    });
-    it("should emit undefined when event is removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        eventStore.remove(profile);
-        expect(spy.getValues()).toEqual([profile, undefined]);
-    });
-    it("should not complete when event is removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        eventStore.remove(profile);
-        expect(spy.receivedComplete()).toBe(false);
-    });
-    it("should emit event when re-added", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        eventStore.remove(profile);
-        eventStore.add(profile);
-        expect(spy.getValues()).toEqual([profile, undefined, profile]);
-    });
-    it("should claim event", () => {
-        eventStore.add(profile);
-        eventStore.replaceable(0, user.pubkey).subscribe();
-        expect(eventStore.database.isClaimed(profile)).toBe(true);
-    });
-    it("should remove claim when event is removed", () => {
-        eventStore.add(profile);
-        eventStore.replaceable(0, user.pubkey).subscribe();
-        eventStore.remove(profile);
-        expect(eventStore.database.isClaimed(profile)).toBe(false);
-    });
-    it("should ignore older events added later", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        eventStore.add(user.profile({ name: "old name" }, { created_at: profile.created_at - 500 }));
-        eventStore.add(user.profile({ name: "really old name" }, { created_at: profile.created_at - 1000 }));
-        expect(spy.getValues()).toEqual([profile]);
-    });
-    it("should emit newer events", () => {
-        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
-        eventStore.add(profile);
-        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 500 });
-        eventStore.add(newProfile);
-        expect(spy.getValues()).toEqual([profile, newProfile]);
-    });
-});
-describe("timeline", () => {
-    it("should emit an empty array if there are not events", () => {
-        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [1] }));
-        expect(spy.getValues()).toEqual([[]]);
-    });
-    it("should emit existing events", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
-        expect(spy.getValues()).toEqual([[profile]]);
-    });
-    it("should emit new events", () => {
-        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0, 1] }));
-        eventStore.add(profile);
-        eventStore.add(note);
-        expect(spy.getValues()).toEqual([[], [profile], [note, profile]]);
-    });
-    it("should remove event when its removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
-        eventStore.remove(profile);
-        expect(spy.getValues()).toEqual([[profile], []]);
-    });
-    it("should not emit when other events are removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
-        eventStore.add(note);
-        eventStore.remove(note);
-        expect(spy.getValues()).toEqual([[profile]]);
-    });
-    it("should ignore older events added later", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
-        eventStore.add(user.profile({ name: "old-name" }, { created_at: profile.created_at - 1000 }));
-        expect(spy.getValues()).toEqual([[profile]]);
-    });
-    it("should return new array for every value", () => {
-        const first = user.note("first note");
-        const second = user.note("second note");
-        const third = user.note("third note");
-        eventStore.add(first);
-        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
-        eventStore.add(second);
-        eventStore.add(third);
-        const hasDuplicates = (arr) => {
-            return new Set(arr).size !== arr.length;
-        };
-        expect(hasDuplicates(spy.getValues())).toBe(false);
-    });
-});
-describe("replaceableSet", () => {
-    it("should not emit if there are not events", () => {
-        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
-        expect(spy.receivedNext()).toBe(false);
-    });
-    it("should emit existing events", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
-        expect(spy.getValues()).toEqual([{ [getEventUID(profile)]: profile }]);
-    });
-    it("should remove event when removed", () => {
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
-        eventStore.remove(profile);
-        expect(spy.getValues()).toEqual([{ [getEventUID(profile)]: profile }, {}]);
-    });
-    it("should replace older events", () => {
-        const event2 = { ...profile, created_at: profile.created_at + 100, id: "newer-event" };
-        const uid = getEventUID(profile);
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
-        eventStore.add(event2);
-        expect(spy.getValues()).toEqual([{ [uid]: profile }, { [uid]: event2 }]);
-    });
-    it("should ignore old events added later", () => {
-        const old = user.profile({ name: "old-name" }, { created_at: profile.created_at - 1000 });
-        const uid = getEventUID(profile);
-        eventStore.add(profile);
-        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
-        eventStore.add(old);
-        expect(spy.getValues()).toEqual([{ [uid]: profile }]);
-    });
-});

package/dist/helpers/__tests__/blossom.test.d.ts

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

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

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { areBlossomServersEqual } from "../blossom.js";
-describe("areBlossomServersEqual", () => {
-    it("should ignore path", () => {
-        expect(areBlossomServersEqual("https://cdn.server.com/pathname", "https://cdn.server.com")).toBe(true);
-    });
-    it("should not ignore protocol", () => {
-        expect(areBlossomServersEqual("http://cdn.server.com", "https://cdn.server.com")).toBe(false);
-    });
-    it("should not ignore port", () => {
-        expect(areBlossomServersEqual("http://cdn.server.com:4658", "https://cdn.server.com")).toBe(false);
-    });
-});

package/dist/helpers/__tests__/bookmarks.test.d.ts

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

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

@@ -1,88 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { kinds } from "nostr-tools";
-import { mergeBookmarks } from "../bookmarks.js";
-describe("mergeBookmarks", () => {
-    it("should merge bookmarks and handle duplicates", () => {
-        // Create test data with some duplicates
-        const eventPointer1 = {
-            id: "event1",
-            relays: ["wss://relay1.com/", "wss://relay2.com/"],
-            author: "author1",
-        };
-        const eventPointer2 = {
-            id: "event1", // Same ID as eventPointer1
-            relays: ["wss://relay2.com/", "wss://relay3.com/"],
-            author: "author1",
-        };
-        const eventPointer3 = {
-            id: "event2",
-            relays: ["wss://relay1.com/"],
-            author: "author2",
-        };
-        const addressPointer1 = {
-            kind: kinds.LongFormArticle,
-            pubkey: "pubkey1",
-            identifier: "article1",
-            relays: ["wss://relay1.com/", "wss://relay2.com/"],
-        };
-        const addressPointer2 = {
-            kind: kinds.LongFormArticle,
-            pubkey: "pubkey1",
-            identifier: "article1", // Same as addressPointer1
-            relays: ["wss://relay3.com/"],
-        };
-        const bookmark1 = {
-            notes: [eventPointer1],
-            articles: [addressPointer1],
-            hashtags: ["tag1", "tag2"],
-            urls: ["https://example1.com/"],
-        };
-        const bookmark2 = {
-            notes: [eventPointer2, eventPointer3],
-            articles: [addressPointer2],
-            hashtags: ["tag2", "tag3"],
-            urls: ["https://example1.com/", "https://example2.com/"],
-        };
-        const result = mergeBookmarks(bookmark1, bookmark2);
-        // Check that duplicates are properly merged
-        expect(result.notes).toHaveLength(2); // event1 should be merged, plus event2
-        expect(result.articles).toHaveLength(1); // article1 should be merged
-        expect(result.hashtags).toHaveLength(3); // unique tags
-        expect(result.urls).toHaveLength(2); // unique urls
-        // Check that relays are merged for duplicate event
-        const mergedEvent = result.notes.find((note) => note.id === "event1");
-        expect(mergedEvent?.relays).toHaveLength(3);
-        expect(mergedEvent?.relays).toContain("wss://relay1.com/");
-        expect(mergedEvent?.relays).toContain("wss://relay2.com/");
-        expect(mergedEvent?.relays).toContain("wss://relay3.com/");
-        // Check that relays are merged for duplicate article
-        const mergedArticle = result.articles[0];
-        expect(mergedArticle.relays).toHaveLength(3);
-        expect(mergedArticle.relays).toContain("wss://relay1.com/");
-        expect(mergedArticle.relays).toContain("wss://relay2.com/");
-        expect(mergedArticle.relays).toContain("wss://relay3.com/");
-        // Check that hashtags are unique
-        expect(result.hashtags).toContain("tag1");
-        expect(result.hashtags).toContain("tag2");
-        expect(result.hashtags).toContain("tag3");
-        // Check that urls are unique
-        expect(result.urls).toContain("https://example1.com/");
-        expect(result.urls).toContain("https://example2.com/");
-    });
-    it("should handle undefined bookmarks", () => {
-        const bookmark = {
-            notes: [{ id: "event1", relays: ["wss://relay1.com/"] }],
-            articles: [],
-            hashtags: ["tag1"],
-            urls: ["https://example.com/"],
-        };
-        const result = mergeBookmarks(bookmark, undefined);
-        expect(result).toEqual(bookmark);
-        expect(mergeBookmarks(undefined, undefined)).toEqual({
-            notes: [],
-            articles: [],
-            hashtags: [],
-            urls: [],
-        });
-    });
-});

package/dist/helpers/__tests__/comment.test.d.ts

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