applesauce-core 0.0.0-next-20250919114711 → 0.0.0-next-20250923113611

package/dist/helpers/app-data.d.ts

@@ -2,6 +2,7 @@ import { NostrEvent } from "nostr-tools";
 import { EncryptionMethod } from "./encrypted-content.js";
 import { HiddenContentSigner } from "./hidden-content.js";
 export declare const APP_DATA_KIND = 30078;
+/** A symbol used to cache the application data content */
 export declare const AppDataContentSymbol: unique symbol;
 /** Checks if an event has application data */
 export declare function hasAppData<T extends {
@@ -14,7 +15,9 @@ export declare function getAppDataEncryption<T extends {
     content: string;
 }>(event: T): EncryptionMethod | undefined;
 /** Checks if the application data is locked (encrypted and not decrypted) */
-export declare function isAppDataLocked<T extends object>(event: T): boolean;
+export declare function isAppDataUnlocked<T extends {
+    kind: number;
+}>(event: T): boolean;
 /** Returns the parsed application data for an event if it's unlocked */
 export declare function getAppDataContent<R extends unknown = unknown, T extends {
     kind: number;

package/dist/helpers/app-data.js

@@ -1,8 +1,9 @@
 import { isNIP04Encrypted } from "./encryption.js";
-import { getHiddenContent, isHiddenContentLocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "./hidden-content.js";
+import { getHiddenContent, isHiddenContentUnlocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "./hidden-content.js";
 import { safeParse } from "./json.js";
 // NIP-78 Application Data event kind
 export const APP_DATA_KIND = 30078;
+/** A symbol used to cache the application data content */
 export const AppDataContentSymbol = Symbol.for("app-data-content");
 // Set the encryption method for app data events (default to nip44)
 setHiddenContentEncryptionMethod(APP_DATA_KIND, "nip44");
@@ -22,8 +23,8 @@ export function getAppDataEncryption(event) {
     return isNIP04Encrypted(event.content) ? "nip04" : "nip44";
 }
 /** Checks if the application data is locked (encrypted and not decrypted) */
-export function isAppDataLocked(event) {
-    return isHiddenContentLocked(event);
+export function isAppDataUnlocked(event) {
+    return isHiddenContentUnlocked(event);
 }
 /** Returns the parsed application data for an event if it's unlocked */
 export function getAppDataContent(event) {

package/dist/helpers/bookmarks.d.ts

@@ -1,7 +1,12 @@
 import { NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { HiddenContentSigner } from "./index.js";
 export declare const BookmarkPublicSymbol: unique symbol;
 export declare const BookmarkHiddenSymbol: unique symbol;
+/** Type for unlocked bookmarks events */
+export type UnlockedBookmarks = {
+    [BookmarkHiddenSymbol]: Bookmarks;
+};
 export type Bookmarks = {
     notes: EventPointer[];
     articles: AddressPointer[];
@@ -16,5 +21,10 @@ export declare function mergeBookmarks(...bookmarks: (Bookmarks | undefined)[]):
 export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
 /** Returns the public bookmarks of the event */
 export declare function getPublicBookmarks(bookmark: NostrEvent): Bookmarks;
+/** Checks if the hidden bookmarks are unlocked */
+export declare function isHiddenBookmarksUnlocked<T extends NostrEvent>(bookmark: T): bookmark is T & UnlockedBookmarks;
 /** Returns the bookmarks of the event if its unlocked */
-export declare function getHiddenBookmarks(bookmark: NostrEvent): Bookmarks | undefined;
+export declare function getHiddenBookmarks<T extends NostrEvent & UnlockedBookmarks>(bookmark: T): Bookmarks;
+export declare function getHiddenBookmarks<T extends NostrEvent>(bookmark: T): Bookmarks | undefined;
+/** Unlocks the hidden bookmarks on a bookmarks event */
+export declare function unlockHiddenBookmarks(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<Bookmarks>;

package/dist/helpers/bookmarks.js

@@ -1,6 +1,6 @@
 import { kinds } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags, isHiddenTagsLocked } from "./index.js";
+import { getHiddenTags, isHiddenTagsUnlocked, notifyEventUpdate, unlockHiddenTags, } from "./index.js";
 import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, mergeAddressPointers, mergeEventPointers, } from "./pointers.js";
 export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
 export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
@@ -63,9 +63,34 @@ export function getBookmarks(bookmark) {
 export function getPublicBookmarks(bookmark) {
     return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
 }
-/** Returns the bookmarks of the event if its unlocked */
+/** Checks if the hidden bookmarks are unlocked */
+export function isHiddenBookmarksUnlocked(bookmark) {
+    return isHiddenTagsUnlocked(bookmark) && Reflect.has(bookmark, BookmarkHiddenSymbol);
+}
 export function getHiddenBookmarks(bookmark) {
-    if (isHiddenTagsLocked(bookmark))
+    if (isHiddenBookmarksUnlocked(bookmark))
+        return bookmark[BookmarkHiddenSymbol];
+    //get hidden tags
+    const tags = getHiddenTags(bookmark);
+    if (!tags)
         return undefined;
-    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => parseBookmarkTags(getHiddenTags(bookmark)));
+    // parse bookmarks
+    const bookmarks = parseBookmarkTags(tags);
+    // set cached value
+    Reflect.set(bookmark, BookmarkHiddenSymbol, bookmarks);
+    return bookmarks;
+}
+/** Unlocks the hidden bookmarks on a bookmarks event */
+export async function unlockHiddenBookmarks(bookmark, signer) {
+    if (isHiddenBookmarksUnlocked(bookmark))
+        return bookmark[BookmarkHiddenSymbol];
+    // unlock hidden tags
+    await unlockHiddenTags(bookmark, signer);
+    // get hidden bookmarks
+    const bookmarks = getHiddenBookmarks(bookmark);
+    if (!bookmarks)
+        throw new Error("Failed to unlock hidden bookmarks");
+    // notify event store
+    notifyEventUpdate(bookmark);
+    return bookmarks;
 }

package/dist/helpers/comment.d.ts

@@ -1,6 +1,9 @@
 import { NostrEvent } from "nostr-tools";
 import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
+import { KnownEvent } from "./index.js";
 export declare const COMMENT_KIND = 1111;
+/** Type for validated comment events */
+export type CommentEvent = KnownEvent<typeof COMMENT_KIND>;
 export type CommentEventPointer = {
     type: "event";
     id: string;
@@ -22,30 +25,20 @@ export type CommentExternalPointer<T extends keyof ExternalIdentifiers> = Extern
 export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer<keyof ExternalIdentifiers>;
 export declare const CommentRootPointerSymbol: unique symbol;
 export declare const CommentReplyPointerSymbol: unique symbol;
-/**
- * Gets the EventPointer from an array of tags
- * @throws
- */
+/** Gets the EventPointer from an array of tags */
 export declare function getCommentEventPointer(tags: string[][], root?: boolean): CommentEventPointer | null;
-/**
- * Gets the AddressPointer from an array of tags
- * @throws
- */
+/** Gets the AddressPointer from an array of tags */
 export declare function getCommentAddressPointer(tags: string[][], root?: boolean): CommentAddressPointer | null;
-/**
- * Gets the ExternalPointer from an array of tags
- * @throws
- */
+/** Gets the ExternalPointer from an array of tags */
 export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer<keyof ExternalIdentifiers> | null;
-/**
- * Returns the root pointer for a comment
- * @throws
- */
+/** Returns the root pointer for a comment */
+export declare function getCommentRootPointer(comment: CommentEvent): CommentPointer;
 export declare function getCommentRootPointer(comment: NostrEvent): CommentPointer | null;
-/**
- * Returns the reply pointer for a comment
- * @throws
- */
+/** Returns the reply pointer for a comment */
 export declare function getCommentReplyPointer(comment: NostrEvent): CommentPointer | null;
+/** Checks if a pointer is a {@link CommentEventPointer} */
 export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
+/** Checks if a pointer is a {@link CommentAddressPointer} */
 export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;
+/** Checks if a comment event is valid */
+export declare function isValidComment(comment: NostrEvent): comment is CommentEvent;

package/dist/helpers/comment.js

@@ -5,16 +5,14 @@ import { isSafeRelayURL } from "./relays.js";
 export const COMMENT_KIND = 1111;
 export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
 export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
-/**
- * Gets the EventPointer from an array of tags
- * @throws
- */
+/** Gets the EventPointer from an array of tags */
 export function getCommentEventPointer(tags, root = false) {
     const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (eTag) {
+        // Missing kind tag, return null
         if (!kind)
-            throw new Error("Missing kind tag");
+            return null;
         // 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 = {
@@ -28,17 +26,15 @@ export function getCommentEventPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Gets the AddressPointer from an array of tags
- * @throws
- */
+/** Gets the AddressPointer from an array of tags */
 export function getCommentAddressPointer(tags, root = false) {
     const aTag = tags.find((t) => t[0] === (root ? "A" : "a"));
     const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (aTag) {
+        // Missing kind tag, return null
         if (!kind)
-            throw new Error("Missing kind tag");
+            return null;
         const addressPointer = getAddressPointerFromATag(aTag);
         const pointer = {
             type: "address",
@@ -52,16 +48,10 @@ export function getCommentAddressPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Gets the ExternalPointer from an array of tags
- * @throws
- */
+/** Gets the ExternalPointer from an array of tags */
 export function getCommentExternalPointer(tags, root = false) {
     const iTag = tags.find((t) => t[0] === (root ? "I" : "i"));
-    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (iTag) {
-        if (!kind)
-            throw new Error("Missing kind tag");
         return {
             type: "external",
             ...getExternalPointerFromTag(iTag),
@@ -69,13 +59,9 @@ export function getCommentExternalPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Returns the root pointer for a comment
- * @throws
- */
 export function getCommentRootPointer(comment) {
     if (comment.kind !== COMMENT_KIND)
-        throw new Error("Event is not a comment");
+        return null;
     return getOrComputeCachedValue(comment, CommentRootPointerSymbol, () => {
         // check for address pointer first since it can also have E tags
         const A = getCommentAddressPointer(comment.tags, true);
@@ -90,13 +76,10 @@ export function getCommentRootPointer(comment) {
         return null;
     });
 }
-/**
- * Returns the reply pointer for a comment
- * @throws
- */
+/** Returns the reply pointer for a comment */
 export function getCommentReplyPointer(comment) {
     if (comment.kind !== COMMENT_KIND)
-        throw new Error("Event is not a comment");
+        return null;
     return getOrComputeCachedValue(comment, CommentReplyPointerSymbol, () => {
         // check for address pointer first since it can also have E tags
         const A = getCommentAddressPointer(comment.tags, false);
@@ -111,15 +94,21 @@ export function getCommentReplyPointer(comment) {
         return null;
     });
 }
+/** Checks if a pointer is a {@link CommentEventPointer} */
 export function isCommentEventPointer(pointer) {
     return (Reflect.has(pointer, "id") &&
         Reflect.has(pointer, "kind") &&
         !Reflect.has(pointer, "identifier") &&
         typeof pointer.kind === "number");
 }
+/** Checks if a pointer is a {@link CommentAddressPointer} */
 export function isCommentAddressPointer(pointer) {
     return (Reflect.has(pointer, "identifier") &&
         Reflect.has(pointer, "pubkey") &&
         Reflect.has(pointer, "kind") &&
         typeof pointer.kind === "number");
 }
+/** Checks if a comment event is valid */
+export function isValidComment(comment) {
+    return (comment.kind === COMMENT_KIND && getCommentRootPointer(comment) !== null && getCommentReplyPointer(comment) !== null);
+}

package/dist/helpers/contacts.d.ts

@@ -3,7 +3,7 @@ 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;
+export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "inbox" | "outbox" | "all"> | 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 */

package/dist/helpers/contacts.js

@@ -2,7 +2,7 @@ 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";
+import { getHiddenTags, isHiddenTagsUnlocked } 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");
@@ -53,7 +53,7 @@ export function getPublicContacts(event) {
 }
 /** Returns only the hidden contacts from a contacts list event */
 export function getHiddenContacts(event) {
-    if (isHiddenTagsLocked(event))
+    if (isHiddenTagsUnlocked(event))
         return undefined;
     return getOrComputeCachedValue(event, HiddenContactsSymbol, () => processTags(getHiddenTags(event), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
 }

package/dist/helpers/encrypted-content-cache.js

@@ -1,7 +1,7 @@
 import { kinds } from "nostr-tools";
 import { catchError, combineLatest, distinct, EMPTY, filter, isObservable, map, merge, mergeMap, of, switchMap, } from "rxjs";
 import { logger } from "../logger.js";
-import { canHaveEncryptedContent, getEncryptedContent, isEncryptedContentLocked, setEncryptedContentCache, } from "./encrypted-content.js";
+import { canHaveEncryptedContent, getEncryptedContent, isEncryptedContentUnlocked, setEncryptedContentCache, } from "./encrypted-content.js";
 import { notifyEventUpdate } from "./event.js";
 import { getGiftWrapSeal, getSealGiftWrap, getSealRumor } from "./gift-wraps.js";
 /** A symbol that is used to mark encrypted content as being from a cache */
@@ -32,7 +32,7 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     const restore = eventStore.insert$
         .pipe(
     // Look for events that support encrypted content and are locked
-    filter((e) => canHaveEncryptedContent(e.kind) && isEncryptedContentLocked(e)), 
+    filter((e) => canHaveEncryptedContent(e.kind) && isEncryptedContentUnlocked(e) === false), 
     // Get the encrypted content from storage
     mergeMap((event) => 
     // Wait for storage to be available
@@ -52,11 +52,11 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     const restoreSeals = eventStore.update$
         .pipe(
     // Look for gift wraps that are unlocked
-    filter((e) => e.kind === kinds.GiftWrap && !isEncryptedContentLocked(e)), 
+    filter((e) => e.kind === kinds.GiftWrap && isEncryptedContentUnlocked(e)), 
     // Get the seal event
     map((gift) => getGiftWrapSeal(gift)), 
     // Look for gift wraps with locked seals
-    filter((seal) => seal !== undefined && isEncryptedContentLocked(seal)), 
+    filter((seal) => seal !== undefined && isEncryptedContentUnlocked(seal) === false), 
     // Only attempt to unlock seals once
     distinct((seal) => seal.id), 
     // Get encrypted content from storage
@@ -84,7 +84,7 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
         .pipe(
     // Look for events that support encrypted content and are unlocked and not from the cache
     filter(([event]) => canHaveEncryptedContent(event.kind) &&
-        !isEncryptedContentLocked(event) &&
+        isEncryptedContentUnlocked(event) &&
         !isEncryptedContentFromCache(event)), 
     // Only persist the encrypted content once
     distinct(([event]) => event.id))
@@ -106,13 +106,13 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     const persistSeals = combineLatest([merge(eventStore.update$, eventStore.insert$), storage$])
         .pipe(
     // Look for gift wraps that are unlocked
-    filter(([event]) => event.kind === kinds.GiftWrap && !isEncryptedContentLocked(event)), 
+    filter(([event]) => event.kind === kinds.GiftWrap && isEncryptedContentUnlocked(event)), 
     // Get the seal event
     map(([gift, storage]) => [getGiftWrapSeal(gift), storage]), 
     // Make sure the seal is defined
     filter(([seal]) => seal !== undefined), 
     // Make sure seal is unlocked and not from cache
-    filter(([seal]) => !isEncryptedContentLocked(seal) && !isEncryptedContentFromCache(seal)), 
+    filter(([seal]) => isEncryptedContentUnlocked(seal) && !isEncryptedContentFromCache(seal)), 
     // Only persist the seal once
     distinct(([seal]) => seal.id))
         .subscribe(async ([seal, storage]) => {

package/dist/helpers/encrypted-content.d.ts

@@ -10,7 +10,12 @@ export interface EncryptedContentSigner {
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     };
 }
+/** Encryption method types */
 export type EncryptionMethod = "nip04" | "nip44";
+/** Type for an event who's encrypted content is unlocked */
+export type UnlockedEncryptedContent = {
+    [EncryptedContentSymbol]: string;
+};
 /** A pair of encryption methods for encrypting and decrypting event content */
 export interface EncryptionMethods {
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
@@ -37,14 +42,16 @@ export declare function hasEncryptedContent<T extends {
     content: string;
 }>(event: T): boolean;
 /** Returns the encrypted content for an event if it is unlocked */
+export declare function getEncryptedContent<T extends UnlockedEncryptedContent>(event: T): string;
 export declare function getEncryptedContent<T extends object>(event: T): string | undefined;
-/** Checks if the encrypted content is locked */
-export declare function isEncryptedContentLocked<T extends object>(event: T): boolean;
+/** Checks if the encrypted content is unlocked and casts it to the {@link UnlockedEncryptedContent} type */
+export declare function isEncryptedContentUnlocked<T extends object>(event: T): event is T & UnlockedEncryptedContent;
 /**
  * Unlocks the encrypted content in an event and caches it
  * @param event The event with content to decrypt
  * @param pubkey The other pubkey that encrypted the content
  * @param signer A signer to use to decrypt the content
+ * @throws If the event kind does not support encrypted content
  */
 export declare function unlockEncryptedContent<T extends {
     kind: number;

package/dist/helpers/encrypted-content.js

@@ -1,5 +1,5 @@
 import { kinds } from "nostr-tools";
-import { isEvent, notifyEventUpdate } from "./event.js";
+import { notifyEventUpdate } from "./event.js";
 /** A symbol use to store the encrypted content of an event in memory */
 export const EncryptedContentSymbol = Symbol.for("encrypted-content");
 /** Various event kinds that can have encrypted content and which encryption method they use */
@@ -39,37 +39,40 @@ export function canHaveEncryptedContent(kind) {
 export function hasEncryptedContent(event) {
     return event.content.length > 0;
 }
-/** Returns the encrypted content for an event if it is unlocked */
 export function getEncryptedContent(event) {
     return Reflect.get(event, EncryptedContentSymbol);
 }
-/** Checks if the encrypted content is locked */
-export function isEncryptedContentLocked(event) {
-    return Reflect.has(event, EncryptedContentSymbol) === false;
+/** Checks if the encrypted content is unlocked and casts it to the {@link UnlockedEncryptedContent} type */
+export function isEncryptedContentUnlocked(event) {
+    return Reflect.has(event, EncryptedContentSymbol) === true;
 }
 /**
  * Unlocks the encrypted content in an event and caches it
  * @param event The event with content to decrypt
  * @param pubkey The other pubkey that encrypted the content
  * @param signer A signer to use to decrypt the content
+ * @throws If the event kind does not support encrypted content
  */
 export async function unlockEncryptedContent(event, pubkey, signer) {
+    if (!canHaveEncryptedContent(event.kind))
+        throw new Error("Event kind does not support encrypted content");
+    // Get the encryption methods from the signer
     const encryption = getEncryptedContentEncryptionMethods(event.kind, signer);
     const plaintext = await encryption.decrypt(pubkey, event.content);
+    // Set the cached value and trigger update
     setEncryptedContentCache(event, plaintext);
+    // Return the decrypted content
     return plaintext;
 }
 /** Sets the encrypted content on an event and updates it if its part of an event store */
 export function setEncryptedContentCache(event, plaintext) {
     Reflect.set(event, EncryptedContentSymbol, plaintext);
     // if the event has been added to an event store, notify it
-    if (isEvent(event))
-        notifyEventUpdate(event);
+    notifyEventUpdate(event);
 }
 /** Removes the encrypted content cache on an event */
 export function lockEncryptedContent(event) {
     Reflect.deleteProperty(event, EncryptedContentSymbol);
     // if the event has been added to an event store, notify it
-    if (isEvent(event))
-        notifyEventUpdate(event);
+    notifyEventUpdate(event);
 }

package/dist/helpers/event.d.ts

@@ -3,6 +3,10 @@ import { IEventStore } from "../event-store/interface.js";
 export { NostrEvent, EventTemplate, UnsignedEvent, verifiedSymbol, verifyEvent, VerifiedEvent } from "nostr-tools/pure";
 export { bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, binarySearch, } from "nostr-tools/utils";
 export * as kinds from "nostr-tools/kinds";
+/** An event with a known kind. this is used to know if events have been validated */
+export type KnownEvent<K extends number> = Omit<NostrEvent, "kind"> & {
+    kind: K;
+};
 /** A symbol on an event that marks which event store its part of */
 export declare const EventStoreSymbol: unique symbol;
 export declare const EventUIDSymbol: unique symbol;
@@ -41,7 +45,7 @@ export declare function isFromCache(event: NostrEvent): boolean;
 /** Returns the EventStore of an event if its been added to one */
 export declare function getParentEventStore<T extends object>(event: T): IEventStore | undefined;
 /** Notifies the events parent store that an event has been updated */
-export declare function notifyEventUpdate(event: NostrEvent): void;
+export declare function notifyEventUpdate(event: any): void;
 /** Returns the replaceable identifier for a replaceable event */
 export declare function getReplaceableIdentifier(event: NostrEvent): string;
 /** Checks if an event is a NIP-70 protected event */

package/dist/helpers/event.js

@@ -85,6 +85,8 @@ export function getParentEventStore(event) {
 }
 /** Notifies the events parent store that an event has been updated */
 export function notifyEventUpdate(event) {
+    if (!isEvent(event))
+        return;
     const eventStore = getParentEventStore(event);
     if (eventStore)
         eventStore.update(event);

package/dist/helpers/file-metadata.d.ts

@@ -1,7 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 export type FileMetadata = {
     /** URL of the file */
-    url: string;
+    url?: string;
     /** MIME type */
     type?: string;
     /** sha256 hash of the file */
@@ -32,24 +32,19 @@ export type FileMetadata = {
     /** fallback URLs */
     fallback?: string[];
 };
+/** Alias for {@link FileMetadata} */
 export type MediaAttachment = FileMetadata;
 /**
  * Parses file metadata tags into {@link FileMetadata}
  * @throws
  */
 export declare function parseFileMetadataTags(tags: string[][]): FileMetadata;
-/**
- * Parses a imeta tag into a {@link FileMetadata}
- * @throws
- */
+/** Parses a imeta tag into a {@link FileMetadata} */
 export declare function getFileMetadataFromImetaTag(tag: string[]): FileMetadata;
 export declare const MediaAttachmentsSymbol: unique symbol;
 /** Gets all the media attachments on an event */
 export declare function getMediaAttachments(event: NostrEvent): FileMetadata[];
-/**
- * Gets {@link FileMetadata} for a NIP-94 kind 1063 event
- * @throws
- */
+/** Gets {@link FileMetadata} for a NIP-94 kind 1063 event */
 export declare function getFileMetadata(file: NostrEvent): FileMetadata;
 /** Returns the last 64 length hex string in a URL */
 export declare function getSha256FromURL(url: string | URL): string | undefined;

package/dist/helpers/file-metadata.js

@@ -16,8 +16,6 @@ export function parseFileMetadataTags(tags) {
                 break;
         }
     }
-    if (!fields.url)
-        throw new Error("Missing required url in file metadata");
     const metadata = { url: fields.url, fallback };
     // parse size
     if (fields.size)
@@ -47,10 +45,7 @@ export function parseFileMetadataTags(tags) {
         metadata.blurhash = fields.blurhash;
     return metadata;
 }
-/**
- * Parses a imeta tag into a {@link FileMetadata}
- * @throws
- */
+/** Parses a imeta tag into a {@link FileMetadata} */
 export function getFileMetadataFromImetaTag(tag) {
     const parts = tag.slice(1);
     const tags = [];
@@ -81,10 +76,7 @@ export function getMediaAttachments(event) {
             .filter((a) => !!a);
     });
 }
-/**
- * Gets {@link FileMetadata} for a NIP-94 kind 1063 event
- * @throws
- */
+/** Gets {@link FileMetadata} for a NIP-94 kind 1063 event */
 export function getFileMetadata(file) {
     return parseFileMetadataTags(file.tags);
 }

package/dist/helpers/filter.d.ts

@@ -1,13 +1,13 @@
 import { Filter, NostrEvent } from "nostr-tools";
 export { Filter } from "nostr-tools/filter";
 /**
- * Copied from nostr-tools and modified to use getIndexableTags
+ * Copied from nostr-tools and modified to use {@link getIndexableTags}
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
  */
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
-/** Copied from nostr-tools */
+/** Copied from nostr-tools and modified to use {@link matchFilter} */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
-/** Copied from nostr-tools and modified to support undefined  */
+/** Copied from nostr-tools and modified to support undefined values */
 export declare function mergeFilters(...filters: Filter[]): Filter;
 /** Check if two filters are equal */
 export declare function isFilterEqual(a: Filter | Filter[], b: Filter | Filter[]): boolean;

package/dist/helpers/filter.js

@@ -1,7 +1,7 @@
 import equal from "fast-deep-equal";
 import { getIndexableTags } from "./event-tags.js";
 /**
- * Copied from nostr-tools and modified to use getIndexableTags
+ * Copied from nostr-tools and modified to use {@link getIndexableTags}
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
  */
 export function matchFilter(filter, event) {
@@ -31,7 +31,7 @@ export function matchFilter(filter, event) {
         return false;
     return true;
 }
-/** Copied from nostr-tools */
+/** Copied from nostr-tools and modified to use {@link matchFilter} */
 export function matchFilters(filters, event) {
     for (let i = 0; i < filters.length; i++) {
         if (matchFilter(filters[i], event)) {
@@ -40,7 +40,7 @@ export function matchFilters(filters, event) {
     }
     return false;
 }
-/** Copied from nostr-tools and modified to support undefined  */
+/** Copied from nostr-tools and modified to support undefined values */
 export function mergeFilters(...filters) {
     let result = {};
     for (let i = 0; i < filters.length; i++) {