applesauce-core 0.12.1 → 1.0.0

package/dist/helpers/pointers.js

@@ -1,20 +1,20 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
 import { getPublicKey, kinds } from "nostr-tools";
 import { getReplaceableIdentifier } from "./event.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 import { isSafeRelayURL } from "./relays.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
-    const kind = parts[0] && parseInt(parts[0]);
+    const kind = parts[0] ? parseInt(parts[0]) : undefined;
     const pubkey = parts[1];
     const d = parts[2];
-    if (!kind) {
+    if (kind === undefined) {
         if (silent)
             return null;
         else
             throw new Error("Missing kind");
     }
-    if (!pubkey) {
+    if (pubkey === undefined || pubkey === "") {
         if (silent)
             return null;
         else
@@ -155,7 +155,7 @@ export function getCoordinateFromAddressPointer(pointer) {
  * @throws
  */
 export function getAddressPointerForEvent(event, relays) {
-    if (!isParameterizedReplaceableKind(event.kind))
+    if (!isAddressableKind(event.kind))
         throw new Error("Cant get AddressPointer for non-replaceable event");
     const d = getReplaceableIdentifier(event);
     return {
@@ -179,7 +179,7 @@ export function getEventPointerForEvent(event, relays) {
 }
 /** Returns a pointer for a given event */
 export function getPointerForEvent(event, relays) {
-    if (kinds.isParameterizedReplaceableKind(event.kind)) {
+    if (kinds.isAddressableKind(event.kind)) {
         const d = getReplaceableIdentifier(event);
         return {
             type: "naddr",

package/dist/observable/__tests__/listen-latest-updates.test.d.ts

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

package/dist/observable/__tests__/listen-latest-updates.test.js

@@ -0,0 +1,55 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { of } from "rxjs";
+import { EventStore } from "../../event-store/event-store.js";
+import { listenLatestUpdates } from "../listen-latest-updates.js";
+import { FakeUser } from "../../__tests__/fixtures.js";
+let eventStore;
+let user;
+let event;
+beforeEach(() => {
+    eventStore = new EventStore();
+    user = new FakeUser();
+    event = user.note("original content");
+});
+describe("listenLatestUpdates", () => {
+    it("should emit the initial event", () => {
+        const source = of(event);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should emit the event again when it's updated in the event store", () => {
+        // Add the event to the store first
+        eventStore.add(event);
+        // Create a source that emits the event
+        const source = of(event);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        // Create an updated version of the event
+        Reflect.set(event, Symbol.for("new-prop"), "testing");
+        // Update the event in the store
+        eventStore.update(event);
+        // Should have received both the original and updated event
+        expect(spy.getValues()).toEqual([event, event]);
+    });
+    it("should not emit updates for other events", () => {
+        // Add the event to the store
+        eventStore.add(event);
+        // Create a source that emits the event
+        const source = of(event);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        // Create a different event
+        const otherEvent = user.note("other content");
+        // Add the other event to the store
+        eventStore.add(otherEvent);
+        // Should only have received the original event
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should handle undefined initial event", () => {
+        const source = of(undefined);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        expect(spy.getValues()).toEqual([undefined]);
+        // Adding events to the store should not trigger emissions
+        eventStore.add(event);
+        expect(spy.getValues()).toEqual([undefined]);
+    });
+});

package/dist/observable/defined.d.ts

@@ -0,0 +1,3 @@
+import { OperatorFunction } from "rxjs";
+/** Filters out undefined and null values */
+export declare function defined<T>(): OperatorFunction<T | undefined, NonNullable<T>>;

package/dist/observable/defined.js

@@ -0,0 +1,5 @@
+import { filter } from "rxjs";
+/** Filters out undefined and null values */
+export function defined() {
+    return (source) => source.pipe(filter((v) => v !== undefined && v !== null));
+}

package/dist/observable/get-observable-value.d.ts

@@ -1,3 +1,6 @@
 import { Observable } from "rxjs";
-/** Subscribes and returns the observables current or next value */
+/**
+ * Subscribes and returns the observables current or next value
+ * @deprecated use `firstValueFrom` instead
+ */
 export declare function getObservableValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/get-observable-value.js

@@ -1,5 +1,8 @@
 import { BehaviorSubject, firstValueFrom } from "rxjs";
-/** Subscribes and returns the observables current or next value */
+/**
+ * Subscribes and returns the observables current or next value
+ * @deprecated use `firstValueFrom` instead
+ */
 export function getObservableValue(observable) {
     if (observable instanceof BehaviorSubject)
         return observable.value;

package/dist/observable/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./share-latest-value.js";
+export * from "./listen-latest-updates.js";
 export * from "./simple-timeout.js";
+export * from "./with-immediate-value.js";

package/dist/observable/index.js

@@ -1,3 +1,5 @@
+export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./share-latest-value.js";
+export * from "./listen-latest-updates.js";
 export * from "./simple-timeout.js";
+export * from "./with-immediate-value.js";

package/dist/observable/listen-latest-updates.d.ts

@@ -0,0 +1,5 @@
+import { NostrEvent } from "nostr-tools";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IStreamEventStore } from "../event-store/interface.js";
+/** Lists for any updates to the latest event and remits it */
+export declare function listenLatestUpdates(eventStore: IStreamEventStore): MonoTypeOperatorFunction<NostrEvent | undefined>;

package/dist/observable/listen-latest-updates.js

@@ -0,0 +1,12 @@
+import { filter, merge, tap } from "rxjs";
+/** Lists for any updates to the latest event and remits it */
+export function listenLatestUpdates(eventStore) {
+    return (source) => {
+        let latest;
+        return merge(
+        // Get the latest event
+        source.pipe(tap((value) => (latest = value))), 
+        // listen for updates
+        eventStore.updates.pipe(filter((e) => e.id === latest?.id)));
+    };
+}

package/dist/queries/blossom.js

@@ -1,10 +1,5 @@
 import { map } from "rxjs/operators";
 import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
 export function UserBlossomServersQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey)
-            .pipe(map((event) => event && getBlossomServersFromList(event))),
-    };
+    return (store) => store.replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey).pipe(map((event) => event && getBlossomServersFromList(event)));
 }

package/dist/queries/bookmarks.d.ts

@@ -1,8 +1,8 @@
 import { Bookmarks } from "../helpers/bookmarks.js";
 import { Query } from "../query-store/index.js";
+/** A query that returns all the bookmarks of a user */
 export declare function UserBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
-export declare function UserHiddenBookmarkQuery(pubkey: string): Query<(Bookmarks & {
-    locked: false;
-}) | {
-    locked: true;
-} | undefined>;
+/** A query that returns all the public bookmarks of a user */
+export declare function UserPublicBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
+/** A query that returns all the hidden bookmarks of a user */
+export declare function UserHiddenBookmarkQuery(pubkey: string): Query<Bookmarks | null | undefined>;

package/dist/queries/bookmarks.js

@@ -1,23 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { isHiddenTagsLocked } from "../helpers/index.js";
-import { getBookmarks, getHiddenBookmarks } from "../helpers/bookmarks.js";
+import { getBookmarks, getHiddenBookmarks, getPublicBookmarks } from "../helpers/bookmarks.js";
+import { listenLatestUpdates } from "../observable/index.js";
+/** A query that returns all the bookmarks of a user */
 export function UserBookmarkQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getBookmarks(event))),
-    };
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all bookmarks
+    map((event) => event && getBookmarks(event)));
 }
+/** A query that returns all the public bookmarks of a user */
+export function UserPublicBookmarkQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicBookmarks(event)));
+}
+/** A query that returns all the hidden bookmarks of a user */
 export function UserHiddenBookmarkQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const bookmarks = getHiddenBookmarks(event);
-            if (isHiddenTagsLocked(event) || !bookmarks)
-                return { locked: true };
-            return { locked: false, ...bookmarks };
-        })),
-    };
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden bookmarks
+    map((event) => event && (getHiddenBookmarks(event) ?? null)));
 }

package/dist/queries/channels.js

@@ -4,70 +4,58 @@ import { map } from "rxjs";
 import { getChannelMetadataContent } from "../helpers/channels.js";
 /** A query that returns a map of hidden messages Map<id, reason> */
 export function ChannelHiddenQuery(channel, authors = []) {
-    return {
-        key: channel.id,
-        run: (events) => {
-            const hidden = new Map();
-            return events
-                .filters([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
-                .pipe(map((event) => {
-                const reason = safeParse(event.content)?.reason;
-                for (const tag of event.tags) {
-                    if (tag[0] === "e" && tag[1])
-                        hidden.set(tag[1], reason ?? "");
-                }
-                return hidden;
-            }));
-        },
+    return (events) => {
+        const hidden = new Map();
+        return events
+            .filters([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+            .pipe(map((event) => {
+            const reason = safeParse(event.content)?.reason;
+            for (const tag of event.tags) {
+                if (tag[0] === "e" && tag[1])
+                    hidden.set(tag[1], reason ?? "");
+            }
+            return hidden;
+        }));
     };
 }
 /** A query that returns all messages in a channel */
 export function ChannelMessagesQuery(channel) {
-    return {
-        key: channel.id,
-        run: (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]),
-    };
+    return (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]);
 }
 /** A query that returns the latest parsed metadata */
 export function ChannelMetadataQuery(channel) {
-    return {
-        key: channel.id,
-        run: (events) => {
-            const filters = [
-                { ids: [channel.id] },
-                { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
-            ];
-            let latest = channel;
-            return events.filters(filters).pipe(map((event) => {
-                try {
-                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
-                        latest = event;
-                    }
-                    return getChannelMetadataContent(latest);
+    return (events) => {
+        const filters = [
+            { ids: [channel.id] },
+            { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
+        ];
+        let latest = channel;
+        return events.filters(filters).pipe(map((event) => {
+            try {
+                if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                    latest = event;
                 }
-                catch (error) {
-                    return undefined;
-                }
-            }));
-        },
+                return getChannelMetadataContent(latest);
+            }
+            catch (error) {
+                return undefined;
+            }
+        }));
     };
 }
 /** A query that returns a map of muted users Map<pubkey, reason> */
 export function ChannelMutedQuery(channel, authors = []) {
-    return {
-        key: channel.id + authors.join(","),
-        run: (events) => {
-            const muted = new Map();
-            return events
-                .filters([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
-                .pipe(map((event) => {
-                const reason = safeParse(event.content)?.reason;
-                for (const tag of event.tags) {
-                    if (tag[0] === "p" && tag[1])
-                        muted.set(tag[1], reason ?? "");
-                }
-                return muted;
-            }));
-        },
+    return (events) => {
+        const muted = new Map();
+        return events
+            .filters([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+            .pipe(map((event) => {
+            const reason = safeParse(event.content)?.reason;
+            for (const tag of event.tags) {
+                if (tag[0] === "p" && tag[1])
+                    muted.set(tag[1], reason ?? "");
+            }
+            return muted;
+        }));
     };
 }

package/dist/queries/comments.js

@@ -1,14 +1,11 @@
 import { COMMENT_KIND, getEventUID } from "../helpers/index.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 /** Returns all NIP-22 comment replies for the event */
 export function CommentsQuery(parent) {
-    return {
-        key: `${getEventUID(parent)}-comments`,
-        run: (events) => {
-            const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
-            if (isParameterizedReplaceableKind(parent.kind))
-                filter["#a"] = [getEventUID(parent)];
-            return events.timeline(filter);
-        },
+    return (events) => {
+        const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
+        if (isAddressableKind(parent.kind))
+            filter["#a"] = [getEventUID(parent)];
+        return events.timeline(filter);
     };
 }

package/dist/queries/contacts.d.ts

@@ -1,3 +1,8 @@
 import { ProfilePointer } from "nostr-tools/nip19";
 import { Query } from "../query-store/index.js";
-export declare function UserContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all contacts for a user */
+export declare function ContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all public contacts for a user */
+export declare function PublicContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all hidden contacts for a user */
+export declare function HiddenContactsQuery(pubkey: string): Query<ProfilePointer[] | null | undefined>;

package/dist/queries/contacts.js

@@ -1,12 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { isPTag, processTags } from "../helpers/tags.js";
-import { getProfilePointerFromPTag } from "../helpers/pointers.js";
-export function UserContactsQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(kinds.Contacts, pubkey)
-            .pipe(map((event) => event && processTags(event.tags.filter(isPTag), getProfilePointerFromPTag))),
-    };
+import { getContacts, getHiddenContacts, getPublicContacts } from "../helpers/contacts.js";
+import { listenLatestUpdates } from "../observable/index.js";
+/** A query that returns all contacts for a user */
+export function ContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all contacts
+    map((e) => e && getContacts(e)));
+}
+/** A query that returns all public contacts for a user */
+export function PublicContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(map((e) => e && getPublicContacts(e)));
+}
+/** A query that returns all hidden contacts for a user */
+export function HiddenContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden contacts
+    map((e) => e && (getHiddenContacts(e) ?? null)));
 }

package/dist/queries/index.d.ts

@@ -3,6 +3,7 @@ export * from "./bookmarks.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./contacts.js";
+export * from "./relays.js";
 export * from "./mailboxes.js";
 export * from "./mutes.js";
 export * from "./pins.js";

package/dist/queries/index.js

@@ -3,6 +3,7 @@ export * from "./bookmarks.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./contacts.js";
+export * from "./relays.js";
 export * from "./mailboxes.js";
 export * from "./mutes.js";
 export * from "./pins.js";

package/dist/queries/mailboxes.js

@@ -3,11 +3,8 @@ import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 /** A query that gets and parses the inbox and outbox relays for a pubkey */
 export function MailboxesQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
-            inboxes: getInboxes(event),
-            outboxes: getOutboxes(event),
-        })),
-    };
+    return (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
+        inboxes: getInboxes(event),
+        outboxes: getOutboxes(event),
+    }));
 }

package/dist/queries/mutes.d.ts

@@ -1,8 +1,8 @@
 import { Mutes } from "../helpers/mutes.js";
 import { Query } from "../query-store/index.js";
-export declare function UserMuteQuery(pubkey: string): Query<Mutes | undefined>;
-export declare function UserHiddenMuteQuery(pubkey: string): Query<(Mutes & {
-    locked: false;
-}) | {
-    locked: true;
-} | undefined>;
+/** A query that returns all a users muted things */
+export declare function MuteQuery(pubkey: string): Query<Mutes | undefined>;
+/** A query that returns all a users public muted things */
+export declare function PublicMuteQuery(pubkey: string): Query<Mutes | undefined>;
+/** A query that returns all a users hidden muted things */
+export declare function HiddenMuteQuery(pubkey: string): Query<Mutes | null | undefined>;

package/dist/queries/mutes.js

@@ -1,23 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { getHiddenMutedThings, getMutedThings } from "../helpers/mutes.js";
-import { isHiddenTagsLocked } from "../helpers/hidden-tags.js";
-export function UserMuteQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (event) => event.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getMutedThings(event))),
-    };
+import { getHiddenMutedThings, getMutedThings, getPublicMutedThings } from "../helpers/mutes.js";
+import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
+/** A query that returns all a users muted things */
+export function MuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all muted things
+    map((event) => event && getMutedThings(event)));
 }
-export function UserHiddenMuteQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const muted = getHiddenMutedThings(event);
-            if (isHiddenTagsLocked(event) || !muted)
-                return { locked: true };
-            return { locked: false, ...muted };
-        })),
-    };
+/** A query that returns all a users public muted things */
+export function PublicMuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicMutedThings(event)));
+}
+/** A query that returns all a users hidden muted things */
+export function HiddenMuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden muted things
+    map((event) => event && getHiddenMutedThings(event)));
 }

package/dist/queries/pins.d.ts

@@ -1,3 +1,4 @@
 import { Query } from "applesauce-core";
 import { EventPointer } from "nostr-tools/nip19";
+/** A query that returns all pinned pointers for a user */
 export declare function UserPinnedQuery(pubkey: string): Query<EventPointer[] | undefined>;

package/dist/queries/pins.js

@@ -2,11 +2,9 @@ import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { isETag, processTags } from "../helpers/tags.js";
 import { getEventPointerFromETag } from "../helpers/pointers.js";
+/** A query that returns all pinned pointers for a user */
 export function UserPinnedQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(kinds.Pinlist, pubkey)
-            .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag))),
-    };
+    return (events) => events
+        .replaceable(kinds.Pinlist, pubkey)
+        .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag)));
 }

package/dist/queries/profile.js

@@ -3,10 +3,5 @@ import { filter, map } from "rxjs/operators";
 import { getProfileContent, isValidProfile } from "../helpers/profile.js";
 /** A query that gets and parses the kind 0 metadata for a pubkey */
 export function ProfileQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => {
-            return events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
-        },
-    };
+    return (events) => events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
 }

package/dist/queries/reactions.js

@@ -2,18 +2,15 @@ import { kinds } from "nostr-tools";
 import { getEventUID, isReplaceable } from "../helpers/event.js";
 /** A query that returns all reactions to an event (supports replaceable events) */
 export function ReactionsQuery(event) {
-    return {
-        key: getEventUID(event),
-        run: (events) => events.timeline(isReplaceable(event.kind)
-            ? [
-                { kinds: [kinds.Reaction], "#e": [event.id] },
-                { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
-            ]
-            : [
-                {
-                    kinds: [kinds.Reaction],
-                    "#e": [event.id],
-                },
-            ]),
-    };
+    return (events) => events.timeline(isReplaceable(event.kind)
+        ? [
+            { kinds: [kinds.Reaction], "#e": [event.id] },
+            { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
+        ]
+        : [
+            {
+                kinds: [kinds.Reaction],
+                "#e": [event.id],
+            },
+        ]);
 }

package/dist/queries/relays.d.ts

@@ -0,0 +1,27 @@
+import { AddressPointer } from "nostr-tools/nip19";
+import { ReadListTags } from "../helpers/lists.js";
+import { Query } from "../query-store/query-store.js";
+/**
+ * A query that returns all favorite relays for a pubkey
+ * @param pubkey - The pubkey to get the favorite relays for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;
+/**
+ * A query that returns all favorite relay sets for a pubkey
+ * @param pubkey - The pubkey to get the favorite relay sets for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelaySets(pubkey: string, type?: ReadListTags): Query<AddressPointer[] | undefined>;
+/**
+ * A query that returns all search relays for a pubkey
+ * @param pubkey - The pubkey to get the search relays for
+ * @param type - Which types of tags to read
+ */
+export declare function SearchRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;
+/**
+ * A query that returns all blocked relays for a pubkey
+ * @param pubkey - The pubkey to get the blocked relays for
+ * @param type - Which types of tags to read
+ */
+export declare function BlockedRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;