applesauce-core 0.12.0 → 1.0.0

package/dist/helpers/lists.js

@@ -1,55 +1,94 @@
-import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { getHiddenTags } from "./hidden-tags.js";
 import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "./pointers.js";
 import { isATag, isETag, isPTag, processTags } from "./tags.js";
 import { getReplaceableIdentifier } from "./event.js";
-function listGetAllTags(list) {
-    const hidden = getHiddenTags(list);
-    return hidden ? [...hidden, ...list.tags] : list.tags;
+import { mergeRelaySets } from "./relays.js";
+export const FAVORITE_RELAYS_KIND = 10012;
+/** Returns all the tags of a list or set */
+export function getListTags(list, type) {
+    switch (type) {
+        case "public":
+            return list.tags;
+        case "hidden":
+            return getHiddenTags(list) ?? [];
+        default:
+        case "all":
+            return [...(getHiddenTags(list) ?? []), ...list.tags];
+    }
 }
 /**
  * Checks if an event pointer is anywhere in a list or set
  * NOTE: Ignores the `relay` field in EventPointer
- * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ * @param list - The list or set to check
+ * @param pointer - The event pointer to check
+ * @param type - Which types of tags to check
  */
-export function isEventPointerInList(list, pointer) {
+export function isEventPointerInList(list, pointer, type) {
     const id = typeof pointer === "string" ? pointer : pointer.id;
-    return listGetAllTags(list).some((t) => t[0] === "e" && t[1] === id);
+    const tags = getListTags(list, type);
+    return tags.some((t) => t[0] === "e" && t[1] === id);
 }
 /**
  * Checks if an address pointer is anywhere in a list or set
  * NOTE: Ignores the `relay` field in AddressPointer
- * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ * @param list - The list or set to check
+ * @param pointer - The address pointer to check
+ * @param type - Which types of tags to check
  */
-export function isAddressPointerInList(list, pointer) {
+export function isAddressPointerInList(list, pointer, type) {
     const cord = typeof pointer === "string" ? pointer : getCoordinateFromAddressPointer(pointer);
-    return listGetAllTags(list).some((t) => t[0] === "a" && t[1] === cord);
+    const tags = getListTags(list, type);
+    return tags.some((t) => t[0] === "a" && t[1] === cord);
 }
 /**
  * Checks if an profile pointer is anywhere in a list or set
  * NOTE: Ignores the `relay` field in ProfilePointer
- * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ * @param list - The list or set to check
+ * @param pointer - The profile pointer to check
+ * @param type - Which types of tags to check
  */
-export function isProfilePointerInList(list, pointer) {
+export function isProfilePointerInList(list, pointer, type) {
     const pubkey = typeof pointer === "string" ? pointer : pointer.pubkey;
-    return listGetAllTags(list).some((t) => t[0] === "p" && t[1] === pubkey);
+    const tags = getListTags(list, type);
+    return tags.some((t) => t[0] === "p" && t[1] === pubkey);
 }
-/** Returns all the EventPointer in a list or set */
-export function getEventPointersFromList(list) {
-    return processTags(listGetAllTags(list), (tag) => (isETag(tag) ? tag : undefined), getEventPointerFromETag);
+/**
+ * Returns all the EventPointer in a list or set
+ * @param list - The list or set to get the event pointers from
+ * @param type - Which types of tags to read
+ */
+export function getEventPointersFromList(list, type) {
+    return processTags(getListTags(list, type), (tag) => (isETag(tag) ? tag : undefined), getEventPointerFromETag);
+}
+/**
+ * Returns all the AddressPointer in a list or set
+ * @param list - The list or set to get the address pointers from
+ * @param type - Which types of tags to read
+ */
+export function getAddressPointersFromList(list, type) {
+    return processTags(getListTags(list, type), (t) => (isATag(t) ? t : undefined), getAddressPointerFromATag);
 }
-/** Returns all the AddressPointer in a list or set */
-export function getAddressPointersFromList(list) {
-    return processTags(listGetAllTags(list), (t) => (isATag(t) ? t : undefined), getAddressPointerFromATag);
+/**
+ * Returns all the ProfilePointer in a list or set
+ * @param list - The list or set to get the profile pointers from
+ * @param type - Which types of tags to read
+ */
+export function getProfilePointersFromList(list, type) {
+    return processTags(getListTags(list, type), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag);
 }
-/** Returns all the ProfilePointer in a list or set */
-export function getProfilePointersFromList(list) {
-    return processTags(listGetAllTags(list), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag);
+/**
+ * Returns a deduplicated array of all 'relay' tags in a list or set
+ * @param list - The list or set to get the relays from
+ * @param type - Which types of tags to read
+ */
+export function getRelaysFromList(list, type) {
+    return mergeRelaySets(processTags(getListTags(list, type), (t) => (t[0] === "relay" ? t[1] : undefined)));
 }
 /** Returns if an event is a valid list or set */
 export function isValidList(event) {
     try {
-        if (isParameterizedReplaceableKind(event.kind)) {
+        if (isAddressableKind(event.kind)) {
             // event is a set
             // ensure the set has an identifier
             getReplaceableIdentifier(event);

package/dist/helpers/mutes.d.ts

@@ -7,9 +7,17 @@ export type Mutes = {
     hashtags: Set<string>;
     words: Set<string>;
 };
+/** Merges any number of mute sets */
+export declare function mergeMutes(...mutes: Mutes[]): Mutes;
 /** Parses mute tags */
 export declare function parseMutedTags(tags: string[][]): Mutes;
 /** Returns muted things */
 export declare function getMutedThings(mute: NostrEvent): Mutes;
+/** Returns only the public muted things from a mute event */
+export declare function getPublicMutedThings(mute: NostrEvent): Mutes;
 /** Returns the hidden muted content if the event is unlocked */
 export declare function getHiddenMutedThings(mute: NostrEvent): Mutes | undefined;
+/** Creates a RegExp for matching muted words */
+export declare function createMutedWordsRegExp(mutedWords: string[]): RegExp;
+/** Returns true if the event matches the mutes */
+export declare function matchMutes(mutes: Mutes, event: NostrEvent): boolean;

package/dist/helpers/mutes.js

@@ -1,8 +1,25 @@
+import { kinds } from "nostr-tools";
 import { isETag, isPTag, isTTag } from "./tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags } from "./hidden-tags.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
+import { getIndexableTags, getNip10References } from "./index.js";
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
+/** Merges any number of mute sets */
+export function mergeMutes(...mutes) {
+    const mute = { pubkeys: new Set(), threads: new Set(), hashtags: new Set(), words: new Set() };
+    for (const m of mutes) {
+        for (const pubkey of m.pubkeys)
+            mute.pubkeys.add(pubkey);
+        for (const thread of m.threads)
+            mute.threads.add(thread);
+        for (const hashtag of m.hashtags)
+            mute.hashtags.add(hashtag);
+        for (const word of m.words)
+            mute.words.add(word);
+    }
+    return mute;
+}
 /** Parses mute tags */
 export function parseMutedTags(tags) {
     const pubkeys = new Set(tags.filter(isPTag).map((t) => t[1]));
@@ -13,12 +30,56 @@ export function parseMutedTags(tags) {
 }
 /** Returns muted things */
 export function getMutedThings(mute) {
+    const hidden = getHiddenMutedThings(mute);
+    const mutes = getPublicMutedThings(mute);
+    if (hidden)
+        return mergeMutes(hidden, mutes);
+    return mutes;
+}
+/** Returns only the public muted things from a mute event */
+export function getPublicMutedThings(mute) {
     return getOrComputeCachedValue(mute, MutePublicSymbol, () => parseMutedTags(mute.tags));
 }
 /** Returns the hidden muted content if the event is unlocked */
 export function getHiddenMutedThings(mute) {
-    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => {
-        const tags = getHiddenTags(mute);
-        return tags && parseMutedTags(tags);
-    });
+    if (isHiddenTagsLocked(mute))
+        return undefined;
+    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => parseMutedTags(getHiddenTags(mute)));
+}
+/** Creates a RegExp for matching muted words */
+export function createMutedWordsRegExp(mutedWords) {
+    // Escape special characters and join with |
+    const escapedWords = mutedWords.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    // Create the RegExp with word boundaries and case insensitive flag
+    return new RegExp(`\\b(${escapedWords.join("|")})\\b`, "gi");
+}
+/** Returns true if the event matches the mutes */
+export function matchMutes(mutes, event) {
+    // Filter on muted pubkeys
+    if (mutes.pubkeys.size > 0) {
+        if (mutes.pubkeys.has(event.pubkey))
+            return true;
+    }
+    // Filter on muted hashtags`
+    if (mutes.hashtags.size > 0) {
+        const tags = getIndexableTags(event);
+        for (let tag of mutes.hashtags) {
+            if (tags.has("t:" + tag))
+                return true;
+        }
+    }
+    // Filter on muted threads
+    if (mutes.threads.size > 0 && event.kind === kinds.ShortTextNote) {
+        const refs = getNip10References(event);
+        if (refs.root?.e && mutes.threads.has(refs.root.e.id))
+            return true;
+    }
+    // Filter on muted words
+    if (mutes.words.size > 0) {
+        const regExp = createMutedWordsRegExp(Array.from(mutes.words));
+        if (regExp.test(event.content))
+            return true;
+    }
+    // Event does not match any mutes
+    return false;
 }

package/dist/helpers/nip-19.d.ts

@@ -1,4 +1,18 @@
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 /** Gets the hex pubkey from any nip-19 encoded string */
 export declare function normalizeToPubkey(str: string): string;
 /** Converts hex to nsec strings into Uint8 secret keys */
 export declare function normalizeToSecretKey(str: string): Uint8Array;
+/**
+ * Merges two event points and keeps all relays
+ * @throws if the ids are different
+ */
+export declare function mergeEventPointers(a: EventPointer, b: EventPointer): EventPointer;
+/** Merges two address pointers and keeps all relays
+ * @throws if the kinds, pubkeys, or identifiers are different
+ */
+export declare function mergeAddressPointers(a: AddressPointer, b: AddressPointer): AddressPointer;
+/** Merges two profile pointers and keeps all relays
+ * @throws if the pubkeys are different
+ */
+export declare function mergeProfilePointers(a: ProfilePointer, b: ProfilePointer): ProfilePointer;

package/dist/helpers/nip-19.js

@@ -2,6 +2,7 @@ import { nip19 } from "nostr-tools";
 import { hexToBytes } from "@noble/hashes/utils";
 import { isHexKey } from "./string.js";
 import { getPubkeyFromDecodeResult } from "./pointers.js";
+import { mergeRelaySets } from "./relays.js";
 /** Gets the hex pubkey from any nip-19 encoded string */
 export function normalizeToPubkey(str) {
     if (isHexKey(str))
@@ -25,3 +26,31 @@ export function normalizeToSecretKey(str) {
         return decode.data;
     }
 }
+/**
+ * Merges two event points and keeps all relays
+ * @throws if the ids are different
+ */
+export function mergeEventPointers(a, b) {
+    if (a.id !== b.id)
+        throw new Error("Cant merge event pointers with different ids");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { id: a.id, kind: a.kind ?? b.kind, author: a.author ?? b.author, relays };
+}
+/** Merges two address pointers and keeps all relays
+ * @throws if the kinds, pubkeys, or identifiers are different
+ */
+export function mergeAddressPointers(a, b) {
+    if (a.kind !== b.kind || a.pubkey !== b.pubkey || a.identifier !== b.identifier)
+        throw new Error("Cant merge address pointers with different kinds, pubkeys, or identifiers");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { ...a, relays };
+}
+/** Merges two profile pointers and keeps all relays
+ * @throws if the pubkeys are different
+ */
+export function mergeProfilePointers(a, b) {
+    if (a.pubkey !== b.pubkey)
+        throw new Error("Cant merge profile pointers with different pubkeys");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { ...a, relays };
+}

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;
+        }));
     };
 }