applesauce-core 0.1.0 → 0.3.0

package/dist/helpers/mailboxes.d.ts

@@ -1,3 +1,17 @@
 import { NostrEvent } from "nostr-tools";
+export declare const MailboxesInboxesSymbol: unique symbol;
+export declare const MailboxesOutboxesSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MailboxesInboxesSymbol]?: Set<string>;
+        [MailboxesOutboxesSymbol]?: Set<string>;
+    }
+}
+/**
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
+ */
 export declare function getInboxes(event: NostrEvent): Set<string>;
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
+ */
 export declare function getOutboxes(event: NostrEvent): Set<string>;

package/dist/helpers/mailboxes.js

@@ -1,7 +1,11 @@
 import { safeRelayUrl } from "./relays.js";
-import { MailboxesInboxes, MailboxesOutboxes } from "./symbols.js";
+export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
+export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
+/**
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
+ */
 export function getInboxes(event) {
-    if (!event[MailboxesInboxes]) {
+    if (!event[MailboxesInboxesSymbol]) {
         const inboxes = new Set();
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
@@ -10,12 +14,15 @@ export function getInboxes(event) {
                     inboxes.add(url);
             }
         }
-        event[MailboxesInboxes] = inboxes;
+        event[MailboxesInboxesSymbol] = inboxes;
     }
-    return event[MailboxesInboxes];
+    return event[MailboxesInboxesSymbol];
 }
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
+ */
 export function getOutboxes(event) {
-    if (!event[MailboxesOutboxes]) {
+    if (!event[MailboxesOutboxesSymbol]) {
         const outboxes = new Set();
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
@@ -24,7 +31,7 @@ export function getOutboxes(event) {
                     outboxes.add(url);
             }
         }
-        event[MailboxesOutboxes] = outboxes;
+        event[MailboxesOutboxesSymbol] = outboxes;
     }
-    return event[MailboxesOutboxes];
+    return event[MailboxesOutboxesSymbol];
 }

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

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

package/dist/helpers/mailboxes.test.js

@@ -0,0 +1,80 @@
+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"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/", "read"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+    });
+    describe("getOutboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/", "write"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+    });
+});

package/dist/helpers/mute.d.ts

@@ -0,0 +1,21 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MutePubkeysSymbol: unique symbol;
+export declare const MuteThreadsSymbol: unique symbol;
+export declare const MuteHashtagsSymbol: unique symbol;
+export declare const MuteWordsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MutePubkeysSymbol]?: Set<string>;
+        [MuteThreadsSymbol]?: Set<string>;
+        [MuteHashtagsSymbol]?: Set<string>;
+        [MuteWordsSymbol]?: Set<string>;
+    }
+}
+/** Returns a set of muted pubkeys */
+export declare function getMutedPubkeys(mute: NostrEvent): Set<string>;
+/** Returns a set of muted threads */
+export declare function getMutedThreads(mute: NostrEvent): Set<string>;
+/** Returns a set of muted words ( lowercase ) */
+export declare function getMutedWords(mute: NostrEvent): Set<string>;
+/** Returns a set of muted hashtags ( lowercase ) */
+export declare function getMutedHashtags(mute: NostrEvent): Set<string>;

package/dist/helpers/mute.js

@@ -0,0 +1,52 @@
+export const MutePubkeysSymbol = Symbol.for("mute-pubkeys");
+export const MuteThreadsSymbol = Symbol.for("mute-threads");
+export const MuteHashtagsSymbol = Symbol.for("mute-hashtags");
+export const MuteWordsSymbol = Symbol.for("mute-words");
+/** Returns a set of muted pubkeys */
+export function getMutedPubkeys(mute) {
+    let pubkeys = mute[MutePubkeysSymbol];
+    if (!pubkeys) {
+        pubkeys = mute[MutePubkeysSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "p" && tag[1])
+                pubkeys.add(tag[1]);
+        }
+    }
+    return pubkeys;
+}
+/** Returns a set of muted threads */
+export function getMutedThreads(mute) {
+    let threads = mute[MuteThreadsSymbol];
+    if (!threads) {
+        threads = mute[MuteThreadsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "e" && tag[1])
+                threads.add(tag[1]);
+        }
+    }
+    return threads;
+}
+/** Returns a set of muted words ( lowercase ) */
+export function getMutedWords(mute) {
+    let words = mute[MuteWordsSymbol];
+    if (!words) {
+        words = mute[MuteWordsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "word" && tag[1])
+                words.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return words;
+}
+/** Returns a set of muted hashtags ( lowercase ) */
+export function getMutedHashtags(mute) {
+    let hashtags = mute[MuteHashtagsSymbol];
+    if (!hashtags) {
+        hashtags = mute[MuteHashtagsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "t" && tag[1])
+                hashtags.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return hashtags;
+}

package/dist/helpers/profile.d.ts

@@ -1,4 +1,10 @@
 import { NostrEvent } from "nostr-tools";
+export declare const ProfileContentSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ProfileContentSymbol]?: ProfileContent | Error;
+    }
+}
 export type ProfileContent = {
     name?: string;
     display_name?: string;

package/dist/helpers/profile.js

@@ -1,17 +1,17 @@
-import { ProfileContent } from "./symbols.js";
+export const ProfileContentSymbol = Symbol.for("profile-content");
 export function getProfileContent(event, quite = false) {
-    let cached = event[ProfileContent];
+    let cached = event[ProfileContentSymbol];
     if (!cached) {
         try {
             const profile = JSON.parse(event.content);
             // ensure nip05 is a string
             if (profile.nip05 && typeof profile.nip05 !== "string")
                 profile.nip05 = String(profile.nip05);
-            cached = event[ProfileContent] = profile;
+            cached = event[ProfileContentSymbol] = profile;
         }
         catch (e) {
             if (e instanceof Error)
-                cached = event[ProfileContent] = e;
+                cached = event[ProfileContentSymbol] = e;
         }
     }
     if (cached === undefined) {

package/dist/helpers/relays.d.ts

@@ -1,4 +1,10 @@
 import { NostrEvent } from "nostr-tools";
+export declare const SeenRelaysSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [SeenRelaysSymbol]?: Set<string>;
+    }
+}
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
 export declare function getSeenRelays(event: NostrEvent): Set<string> | undefined;
 export declare function validateRelayURL(relay: string | URL): URL;

package/dist/helpers/relays.js

@@ -1,12 +1,13 @@
-import { FromRelays } from "./symbols.js";
+export const SeenRelaysSymbol = Symbol.for("seen-relays");
+// Seen relays
 export function addSeenRelay(event, relay) {
-    if (!event[FromRelays])
-        event[FromRelays] = new Set();
-    event[FromRelays].add(relay);
-    return event[FromRelays];
+    if (!event[SeenRelaysSymbol])
+        event[SeenRelaysSymbol] = new Set();
+    event[SeenRelaysSymbol].add(relay);
+    return event[SeenRelaysSymbol];
 }
 export function getSeenRelays(event) {
-    return event[FromRelays];
+    return event[SeenRelaysSymbol];
 }
 // Relay URLs
 export function validateRelayURL(relay) {

package/dist/promise/index.d.ts

@@ -1 +1 @@
-export * from './deferred.js';
+export * from "./deferred.js";

package/dist/promise/index.js

@@ -1 +1 @@
-export * from './deferred.js';
+export * from "./deferred.js";

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

@@ -1,26 +1,44 @@
 import Observable from "zen-observable";
-import { LRU } from "tiny-lru";
 import { Filter, NostrEvent } from "nostr-tools";
 import { EventStore } from "../event-store/event-store.js";
-import { ProfileContent } from "../helpers/profile.js";
+import { LRU } from "../utils/lru.js";
+import * as Queries from "./queries/index.js";
+export type Query<T extends unknown> = {
+    key: string;
+    run: (events: EventStore, store: QueryStore) => Observable<T>;
+};
+export type QueryConstructor<T extends unknown, Args extends Array<any>> = (...args: Args) => Query<T>;
 export declare class QueryStore {
+    static Queries: typeof Queries;
     store: EventStore;
     constructor(store: EventStore);
-    singleEvents: LRU<Observable<import("nostr-tools").Event>>;
-    getEvent(id: string): Observable<import("nostr-tools").Event>;
-    getReplaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event>;
-    timelines: LRU<Observable<import("nostr-tools").Event[]>>;
-    getTimeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
-    profiles: LRU<Observable<ProfileContent>>;
-    getProfile(pubkey: string): Observable<ProfileContent>;
-    reactions: LRU<Observable<import("nostr-tools").Event[]>>;
-    getReactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    mailboxes: LRU<Observable<{
+    queries: LRU<Observable<any>>;
+    /** Creates a cached query */
+    runQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
+        key: string;
+        run: (events: EventStore, store: QueryStore) => Observable<T>;
+    }): (...args: Args) => Observable<T>;
+    /** Returns a single event */
+    event(id: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Returns the latest version of a replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Returns an array of events that match the filter */
+    timeline(filters: Filter | Filter[]): Observable<import("nostr-tools").Event[]>;
+    /** Returns the parsed profile (0) for a pubkey */
+    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Returns all reactions for an event (supports replaceable events) */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** Returns the parsed relay list (10002) for the pubkey */
+    mailboxes(pubkey: string): Observable<{
         inboxes: Set<string>;
         outboxes: Set<string>;
-    }>>;
-    getMailboxes(pubkey: string): Observable<{
-        inboxes: Set<string>;
-        outboxes: Set<string>;
-    }>;
+    } | undefined>;
+    /** Returns the parsed mute list for the pubkey */
+    mute(pubkey: string): Observable<{
+        words: Set<string>;
+        pubkeys: Set<string>;
+        threads: Set<string>;
+        hashtags: Set<string>;
+    } | undefined>;
 }
+export { Queries };

package/dist/query-store/index.js

@@ -1,71 +1,53 @@
-import { LRU } from "tiny-lru";
-import { kinds } from "nostr-tools";
-import stringify from "json-stringify-deterministic";
 import { stateful } from "../observable/stateful.js";
-import { getProfileContent } from "../helpers/profile.js";
-import { getEventUID, getReplaceableUID, isReplaceable } from "../helpers/event.js";
-import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+import { LRU } from "../utils/lru.js";
+import * as Queries from "./queries/index.js";
 export class QueryStore {
+    static Queries = Queries;
     store;
     constructor(store) {
         this.store = store;
     }
-    singleEvents = new LRU();
-    getEvent(id) {
-        if (!this.singleEvents.has(id)) {
-            const observable = stateful(this.store.single(id));
-            this.singleEvents.set(id, observable);
-        }
-        return this.singleEvents.get(id);
+    queries = new LRU();
+    /** Creates a cached query */
+    runQuery(queryConstructor) {
+        return (...args) => {
+            const query = queryConstructor(...args);
+            const key = `${queryConstructor.name}|${query.key}`;
+            if (!this.queries.has(key)) {
+                const observable = stateful(query.run(this.store, this));
+                this.queries.set(key, observable);
+                return observable;
+            }
+            return this.queries.get(key);
+        };
     }
-    getReplaceable(kind, pubkey, d) {
-        return this.getEvent(getReplaceableUID(kind, pubkey, d));
+    /** Returns a single event */
+    event(id) {
+        return this.runQuery(Queries.SingleEventQuery)(id);
     }
-    timelines = new LRU();
-    getTimeline(filters) {
-        const key = stringify(filters);
-        if (!this.singleEvents.has(key)) {
-            const observable = stateful(this.store.timeline(filters));
-            this.timelines.set(key, observable);
-        }
-        return this.timelines.get(key);
+    /** Returns the latest version of a replaceable event */
+    replaceable(kind, pubkey, d) {
+        return this.runQuery(Queries.ReplaceableQuery)(kind, pubkey, d);
     }
-    profiles = new LRU();
-    getProfile(pubkey) {
-        if (!this.profiles.has(pubkey)) {
-            const observable = stateful(this.getReplaceable(kinds.Metadata, pubkey).map((event) => getProfileContent(event)));
-            this.profiles.set(pubkey, observable);
-        }
-        return this.profiles.get(pubkey);
+    /** Returns an array of events that match the filter */
+    timeline(filters) {
+        return this.runQuery(Queries.TimelineQuery)(filters);
     }
-    reactions = new LRU();
-    getReactions(event) {
-        const uid = getEventUID(event);
-        if (!this.reactions.has(uid)) {
-            const observable = this.getTimeline(isReplaceable(event.kind)
-                ? [
-                    { kinds: [kinds.Reaction], "#e": [event.id] },
-                    { kinds: [kinds.Reaction], "#a": [uid] },
-                ]
-                : [
-                    {
-                        kinds: [kinds.Reaction],
-                        "#e": [event.id],
-                    },
-                ]);
-            this.reactions.set(uid, observable);
-        }
-        return this.reactions.get(uid);
+    /** Returns the parsed profile (0) for a pubkey */
+    profile(pubkey) {
+        return this.runQuery(Queries.ProfileQuery)(pubkey);
     }
-    mailboxes = new LRU();
-    getMailboxes(pubkey) {
-        if (!this.mailboxes.has(pubkey)) {
-            const observable = stateful(this.getReplaceable(kinds.RelayList, pubkey).map((event) => ({
-                inboxes: getInboxes(event),
-                outboxes: getOutboxes(event),
-            })));
-            this.mailboxes.set(pubkey, observable);
-        }
-        return this.mailboxes.get(pubkey);
+    /** Returns all reactions for an event (supports replaceable events) */
+    reactions(event) {
+        return this.runQuery(Queries.ReactionsQuery)(event);
+    }
+    /** Returns the parsed relay list (10002) for the pubkey */
+    mailboxes(pubkey) {
+        return this.runQuery(Queries.MailboxesQuery)(pubkey);
+    }
+    /** Returns the parsed mute list for the pubkey */
+    mute(pubkey) {
+        return this.runQuery(Queries.UserMuteQuery)(pubkey);
     }
 }
+export { Queries };

package/dist/query-store/queries/channel.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../index.js";
+import { ChannelMetadataContent } from "../../helpers/channel.js";
+/** Creates a query that returns the latest parsed metadata */
+export declare function ChannelMetadataQuery(channel: NostrEvent): Query<ChannelMetadataContent | undefined>;
+/** Creates a query that returns a map of hidden messages Map<id, reason> */
+export declare function ChannelHiddenQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** Creates a query that returns a map of muted users Map<pubkey, reason> */
+export declare function ChannelMutedQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** Creates a query that returns all messages in a channel */
+export declare function ChannelMessagesQuery(channel: NostrEvent): Query<NostrEvent[]>;

package/dist/query-store/queries/channel.js

@@ -0,0 +1,72 @@
+import { kinds } from "nostr-tools";
+import { getChannelMetadataContent } from "../../helpers/channel.js";
+import { safeParse } from "../../helpers/json.js";
+/** Creates 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.stream(filters).map((event) => {
+                try {
+                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                        latest = event;
+                    }
+                    return getChannelMetadataContent(latest);
+                }
+                catch (error) {
+                    return undefined;
+                }
+            });
+        },
+    };
+}
+/** Creates 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
+                .stream([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .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;
+            });
+        },
+    };
+}
+/** Creates 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
+                .stream([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .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;
+            });
+        },
+    };
+}
+/** Creates 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] }]),
+    };
+}

package/dist/query-store/queries/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./simple.js";
+export * from "./profile.js";
+export * from "./mailboxes.js";
+export * from "./reactions.js";
+export * from "./channel.js";
+export * from "./mute.js";

package/dist/query-store/queries/index.js

@@ -0,0 +1,6 @@
+export * from "./simple.js";
+export * from "./profile.js";
+export * from "./mailboxes.js";
+export * from "./reactions.js";
+export * from "./channel.js";
+export * from "./mute.js";

package/dist/query-store/queries/mailboxes.d.ts

@@ -0,0 +1,5 @@
+import { Query } from "../index.js";
+export declare function MailboxesQuery(pubkey: string): Query<{
+    inboxes: Set<string>;
+    outboxes: Set<string>;
+} | undefined>;

package/dist/query-store/queries/mailboxes.js

@@ -0,0 +1,11 @@
+import { kinds } from "nostr-tools";
+import { getInboxes, getOutboxes } from "../../helpers/mailboxes.js";
+export function MailboxesQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => events.replaceable(kinds.RelayList, pubkey).map((event) => event && {
+            inboxes: getInboxes(event),
+            outboxes: getOutboxes(event),
+        }),
+    };
+}

package/dist/query-store/queries/mute.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "../index.js";
+export declare function UserMuteQuery(pubkey: string): Query<{
+    words: Set<string>;
+    pubkeys: Set<string>;
+    threads: Set<string>;
+    hashtags: Set<string>;
+} | undefined>;

package/dist/query-store/queries/mute.js

@@ -0,0 +1,16 @@
+import { kinds } from "nostr-tools";
+import { getMutedHashtags, getMutedPubkeys, getMutedThreads, getMutedWords } from "../../helpers/mute.js";
+export function UserMuteQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).map((event) => {
+            if (!event)
+                return;
+            const pubkeys = getMutedPubkeys(event);
+            const threads = getMutedThreads(event);
+            const hashtags = getMutedHashtags(event);
+            const words = getMutedWords(event);
+            return { pubkeys, threads, hashtags, words };
+        }),
+    };
+}

package/dist/query-store/queries/profile.d.ts

@@ -0,0 +1,3 @@
+import { ProfileContent } from "../../helpers/profile.js";
+import { Query } from "../index.js";
+export declare function ProfileQuery(pubkey: string): Query<ProfileContent | undefined>;

package/dist/query-store/queries/profile.js

@@ -0,0 +1,10 @@
+import { kinds } from "nostr-tools";
+import { getProfileContent } from "../../helpers/profile.js";
+export function ProfileQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => {
+            return events.replaceable(kinds.Metadata, pubkey).map((event) => event && getProfileContent(event));
+        },
+    };
+}

package/dist/query-store/queries/reactions.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../index.js";
+/** Creates a query that returns all reactions to an event (supports replaceable events) */
+export declare function ReactionsQuery(event: NostrEvent): Query<NostrEvent[]>;