applesauce-core 0.12.1 → 1.0.0

package/dist/helpers/bookmarks.js

@@ -1,9 +1,11 @@
 import { kinds } from "nostr-tools";
-import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags } from "./index.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./index.js";
+import { mergeAddressPointers, mergeEventPointers } from "./nip-19.js";
+import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag } from "./pointers.js";
 export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
 export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
+/** Parses an array of tags into a {@link Bookmarks} object */
 export function parseBookmarkTags(tags) {
     const notes = tags.filter((t) => t[0] === "e" && t[1]).map(getEventPointerFromETag);
     const articles = tags
@@ -14,14 +16,57 @@ export function parseBookmarkTags(tags) {
     const urls = tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
     return { notes, articles, hashtags, urls };
 }
-/** Returns the public bookmarks of the event */
+/** Merges any number of {@link Bookmarks} objects */
+export function mergeBookmarks(...bookmarks) {
+    const notes = new Map();
+    const articles = new Map();
+    const hashtags = new Set();
+    const urls = new Set();
+    for (const bookmark of bookmarks) {
+        if (!bookmark)
+            continue;
+        for (const note of bookmark.notes) {
+            const existing = notes.get(note.id);
+            if (existing)
+                notes.set(note.id, mergeEventPointers(existing, note));
+            else
+                notes.set(note.id, note);
+        }
+        for (const article of bookmark.articles) {
+            const coord = getCoordinateFromAddressPointer(article);
+            const existing = articles.get(coord);
+            if (existing)
+                articles.set(coord, mergeAddressPointers(existing, article));
+            else
+                articles.set(coord, article);
+        }
+        for (const hashtag of bookmark.hashtags)
+            hashtags.add(hashtag);
+        for (const url of bookmark.urls)
+            urls.add(url);
+    }
+    return {
+        notes: Array.from(notes.values()),
+        articles: Array.from(articles.values()),
+        hashtags: Array.from(hashtags),
+        urls: Array.from(urls),
+    };
+}
+/** Returns all the bookmarks of the event */
 export function getBookmarks(bookmark) {
+    const hidden = getHiddenBookmarks(bookmark);
+    if (hidden)
+        return mergeBookmarks(hidden, getPublicBookmarks(bookmark));
+    else
+        return getPublicBookmarks(bookmark);
+}
+/** Returns the public bookmarks of the event */
+export function getPublicBookmarks(bookmark) {
     return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
 }
 /** Returns the bookmarks of the event if its unlocked */
 export function getHiddenBookmarks(bookmark) {
-    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => {
-        const tags = getHiddenTags(bookmark);
-        return tags && parseBookmarkTags(tags);
-    });
+    if (isHiddenTagsLocked(bookmark))
+        return undefined;
+    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => parseBookmarkTags(getHiddenTags(bookmark)));
 }

package/dist/helpers/comment.d.ts

@@ -2,20 +2,24 @@ import { NostrEvent } from "nostr-tools";
 import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
 export declare const COMMENT_KIND = 1111;
 export type CommentEventPointer = {
+    type: "event";
     id: string;
     kind: number;
     pubkey?: string;
     relay?: string;
 };
 export type CommentAddressPointer = {
+    type: "address";
     id?: string;
     kind: number;
     pubkey: string;
     identifier: string;
     relay?: string;
 };
-export type CommentExternalPointer = ExternalPointer<keyof ExternalIdentifiers>;
-export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer;
+export type CommentExternalPointer<T extends keyof ExternalIdentifiers> = ExternalPointer<T> & {
+    type: "external";
+};
+export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer<keyof ExternalIdentifiers>;
 export declare const CommentRootPointerSymbol: unique symbol;
 export declare const CommentReplyPointerSymbol: unique symbol;
 /**
@@ -32,7 +36,7 @@ export declare function getCommentAddressPointer(tags: string[][], root?: boolea
  * Gets the ExternalPointer from an array of tags
  * @throws
  */
-export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer | null;
+export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer<keyof ExternalIdentifiers> | null;
 /**
  * Returns the root pointer for a comment
  * @throws

package/dist/helpers/comment.js

@@ -18,6 +18,7 @@ export function getCommentEventPointer(tags, root = false) {
         // only the root pubkey can be gotten from the tags, since due to quotes and mentions there will be many "p" tags for replies
         const rootPubkey = root ? tags.find((t) => t[0] === "P")?.[1] : undefined;
         const pointer = {
+            type: "event",
             id: eTag[1],
             kind: parseInt(kind),
             pubkey: eTag[3] || rootPubkey || undefined,
@@ -40,6 +41,7 @@ export function getCommentAddressPointer(tags, root = false) {
             throw new Error("Missing kind tag");
         const addressPointer = getAddressPointerFromATag(aTag);
         const pointer = {
+            type: "address",
             id: eTag?.[1],
             pubkey: addressPointer.pubkey,
             identifier: addressPointer.identifier,
@@ -60,7 +62,10 @@ export function getCommentExternalPointer(tags, root = false) {
     if (iTag) {
         if (!kind)
             throw new Error("Missing kind tag");
-        return getExternalPointerFromTag(iTag);
+        return {
+            type: "external",
+            ...getExternalPointerFromTag(iTag),
+        };
     }
     return null;
 }

package/dist/helpers/contacts.d.ts

@@ -1,3 +1,14 @@
 import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
 export declare const ContactsRelaysSymbol: unique symbol;
+export declare const PublicContactsSymbol: unique symbol;
+export declare const HiddenContactsSymbol: unique symbol;
 export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "all" | "inbox" | "outbox"> | null;
+/** Merges any number of contact lists into a single list */
+export declare function mergeContacts(...pointers: (ProfilePointer | undefined | (ProfilePointer | undefined)[])[]): ProfilePointer[];
+/** Returns all public and hidden contacts from a contacts list event */
+export declare function getContacts(event: NostrEvent): ProfilePointer[];
+/** Returns only the public contacts from a contacts list event */
+export declare function getPublicContacts(event: NostrEvent): ProfilePointer[];
+/** Returns only the hidden contacts from a contacts list event */
+export declare function getHiddenContacts(event: NostrEvent): ProfilePointer[] | undefined;

package/dist/helpers/contacts.js

@@ -1,6 +1,11 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
+import { isPTag, processTags } from "./tags.js";
+import { getProfilePointerFromPTag } from "./pointers.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
 export const ContactsRelaysSymbol = Symbol.for("contacts-relays");
+export const PublicContactsSymbol = Symbol.for("public-contacts");
+export const HiddenContactsSymbol = Symbol.for("hidden-contacts");
 export function getRelaysFromContactsEvent(event) {
     return getOrComputeCachedValue(event, ContactsRelaysSymbol, () => {
         try {
@@ -23,3 +28,32 @@ export function getRelaysFromContactsEvent(event) {
         }
     });
 }
+/** Merges any number of contact lists into a single list */
+export function mergeContacts(...pointers) {
+    const merged = new Map();
+    for (const arr of pointers) {
+        if (Array.isArray(arr)) {
+            for (const pointer of arr)
+                if (pointer)
+                    merged.set(pointer.pubkey, pointer);
+        }
+        else if (arr) {
+            merged.set(arr.pubkey, arr);
+        }
+    }
+    return Array.from(merged.values());
+}
+/** Returns all public and hidden contacts from a contacts list event */
+export function getContacts(event) {
+    return mergeContacts(getPublicContacts(event), getHiddenContacts(event));
+}
+/** Returns only the public contacts from a contacts list event */
+export function getPublicContacts(event) {
+    return getOrComputeCachedValue(event, PublicContactsSymbol, () => processTags(event.tags, (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+}
+/** Returns only the hidden contacts from a contacts list event */
+export function getHiddenContacts(event) {
+    if (isHiddenTagsLocked(event))
+        return undefined;
+    return getOrComputeCachedValue(event, HiddenContactsSymbol, () => processTags(getHiddenTags(event), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+}

package/dist/helpers/event.d.ts

@@ -24,11 +24,16 @@ export declare function isReplaceable(kind: number): boolean;
 /**
  * Returns the events Unique ID
  * For normal or ephemeral events this is ( event.id )
- * For replaceable events this is ( event.kind + ":" + event.pubkey )
- * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey + ":" )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d )
  */
 export declare function getEventUID(event: NostrEvent): string;
-export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
+/** Returns the replaceable event address for an addressable event */
+export declare function getReplaceableAddress(event: NostrEvent): string;
+/** Creates a replaceable event address from a kind, pubkey, and identifier */
+export declare function createReplaceableAddress(kind: number, pubkey: string, identifier?: string): string;
+/** @deprecated use createReplaceableAddress instead */
+export declare const getReplaceableUID: typeof createReplaceableAddress;
 /** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
 /**

package/dist/helpers/event.js

@@ -1,8 +1,8 @@
-import { kinds, verifiedSymbol } from "nostr-tools";
+import { verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { getHiddenTags } from "./hidden-tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { EventStoreSymbol } from "../event-store/event-store.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
@@ -29,30 +29,38 @@ export function isEvent(event) {
  * or parameterized replaceable ( 30000 <= n < 40000 )
  */
 export function isReplaceable(kind) {
-    return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
+    return isReplaceableKind(kind) || isAddressableKind(kind);
 }
 /**
  * Returns the events Unique ID
  * For normal or ephemeral events this is ( event.id )
- * For replaceable events this is ( event.kind + ":" + event.pubkey )
- * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey + ":" )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d )
  */
 export function getEventUID(event) {
     let uid = event[EventUIDSymbol];
     if (!uid) {
-        if (isReplaceable(event.kind)) {
-            let d = event.tags.find((t) => t[0] === "d")?.[1];
-            uid = getReplaceableUID(event.kind, event.pubkey, d);
-        }
+        if (isReplaceable(event.kind))
+            uid = getReplaceableAddress(event);
         else
             uid = event.id;
         event[EventUIDSymbol] = uid;
     }
     return uid;
 }
-export function getReplaceableUID(kind, pubkey, d) {
-    return d ? kind + ":" + pubkey + ":" + d : kind + ":" + pubkey;
+/** Returns the replaceable event address for an addressable event */
+export function getReplaceableAddress(event) {
+    if (!isReplaceable(event.kind))
+        throw new Error("Event is not replaceable or addressable");
+    const identifier = isAddressableKind(event.kind) ? getReplaceableIdentifier(event) : undefined;
+    return createReplaceableAddress(event.kind, event.pubkey, identifier);
+}
+/** Creates a replaceable event address from a kind, pubkey, and identifier */
+export function createReplaceableAddress(kind, pubkey, identifier) {
+    return kind + ":" + pubkey + ":" + (identifier ?? "");
 }
+/** @deprecated use createReplaceableAddress instead */
+export const getReplaceableUID = createReplaceableAddress;
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
     let indexable = event[EventIndexableTagsSymbol];
@@ -100,8 +108,8 @@ export function getParentEventStore(event) {
  * @throws
  */
 export function getReplaceableIdentifier(event) {
-    if (!isParameterizedReplaceableKind(event.kind))
-        throw new Error("Event is not replaceable");
+    if (!isAddressableKind(event.kind))
+        throw new Error("Event is not addressable");
     return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
         const d = getTagValue(event, "d");
         if (d === undefined)

package/dist/helpers/lists.d.ts

@@ -1,28 +1,56 @@
 import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 import { NostrEvent } from "nostr-tools";
+export declare const FAVORITE_RELAYS_KIND = 10012;
+export type ReadListTags = "public" | "hidden" | "all";
+/** Returns all the tags of a list or set */
+export declare function getListTags(list: NostrEvent, type?: ReadListTags): string[][];
 /**
  * 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 declare function isEventPointerInList(list: NostrEvent, pointer: string | EventPointer): boolean;
+export declare function isEventPointerInList(list: NostrEvent, pointer: string | EventPointer, type?: ReadListTags): boolean;
 /**
  * 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 declare function isAddressPointerInList(list: NostrEvent, pointer: string | AddressPointer): boolean;
+export declare function isAddressPointerInList(list: NostrEvent, pointer: string | AddressPointer, type?: ReadListTags): boolean;
 /**
  * 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 declare function isProfilePointerInList(list: NostrEvent, pointer: string | ProfilePointer): boolean;
-/** Returns all the EventPointer in a list or set */
-export declare function getEventPointersFromList(list: NostrEvent): EventPointer[];
-/** Returns all the AddressPointer in a list or set */
-export declare function getAddressPointersFromList(list: NostrEvent): AddressPointer[];
-/** Returns all the ProfilePointer in a list or set */
-export declare function getProfilePointersFromList(list: NostrEvent): ProfilePointer[];
+export declare function isProfilePointerInList(list: NostrEvent, pointer: string | ProfilePointer, type?: ReadListTags): boolean;
+/**
+ * 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 declare function getEventPointersFromList(list: NostrEvent, type?: ReadListTags): EventPointer[];
+/**
+ * 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 declare function getAddressPointersFromList(list: NostrEvent, type?: ReadListTags): AddressPointer[];
+/**
+ * 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 declare function getProfilePointersFromList(list: NostrEvent, type?: ReadListTags): ProfilePointer[];
+/**
+ * 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 declare function getRelaysFromList(list: NostrEvent, type?: ReadListTags): string[];
 /** Returns if an event is a valid list or set */
 export declare function isValidList(event: NostrEvent): boolean;

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