applesauce-core 0.0.0-next-20241128172721 → 0.0.0-next-20241205190859

package/dist/event-store/event-store.d.ts

@@ -3,15 +3,19 @@ import { Observable } from "rxjs";
 import { Database } from "./database.js";
 export declare class EventStore {
     database: Database;
-    /** Whether to keep old versions of replaceable events */
+    /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
     constructor();
-    /** Adds an event to the database */
+    /** Adds an event to the database and update subscriptions */
     add(event: NostrEvent, fromRelay?: string): NostrEvent;
+    /** Removes an event from the database and updates subscriptions */
+    remove(event: string | NostrEvent): boolean;
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
     protected handleDeleteEvent(deleteEvent: NostrEvent): void;
     protected checkDeleted(event: NostrEvent): boolean;
+    /** Removes any event that is not being used by a subscription */
+    prune(max?: number): number;
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): NostrEvent;
     getAll(filters: Filter[]): Set<NostrEvent>;
@@ -34,8 +38,12 @@ export declare class EventStore {
         pubkey: string;
         identifier?: string;
     }[]): Observable<Map<string, NostrEvent>>;
-    /** Creates an observable that streams all events that match the filter */
-    stream(filters: Filter[]): Observable<NostrEvent>;
+    /**
+     * Creates an observable that streams all events that match the filter
+     * @param filters
+     * @param [onlyNew=false] Only subscribe to new events
+     */
+    stream(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
     /** Creates an observable that updates with an array of sorted events */
-    timeline(filters: Filter[], keepOldVersions?: boolean): Observable<NostrEvent[]>;
+    timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<NostrEvent[]>;
 }

package/dist/event-store/event-store.js

@@ -9,12 +9,12 @@ import { addSeenRelay } from "../helpers/relays.js";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
 export class EventStore {
     database;
-    /** Whether to keep old versions of replaceable events */
+    /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
     constructor() {
         this.database = new Database();
     }
-    /** Adds an event to the database */
+    /** Adds an event to the database and update subscriptions */
     add(event, fromRelay) {
         if (event.kind === kinds.EventDeletion)
             this.handleDeleteEvent(event);
@@ -40,6 +40,16 @@ export class EventStore {
             addSeenRelay(inserted, fromRelay);
         return inserted;
     }
+    /** Removes an event from the database and updates subscriptions */
+    remove(event) {
+        if (typeof event === "string")
+            return this.database.deleteEvent(event);
+        else if (this.database.hasEvent(event.id)) {
+            return this.database.deleteEvent(event.id);
+        }
+        else
+            return false;
+    }
     deletedIds = new Set();
     deletedCoords = new Map();
     handleDeleteEvent(deleteEvent) {
@@ -70,6 +80,10 @@ export class EventStore {
         }
         return false;
     }
+    /** Removes any event that is not being used by a subscription */
+    prune(max) {
+        return this.database.prune(max);
+    }
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event) {
         return this.database.updateEvent(event);
@@ -282,35 +296,30 @@ export class EventStore {
             };
         });
     }
-    /** Creates an observable that streams all events that match the filter */
-    stream(filters) {
+    /**
+     * Creates an observable that streams all events that match the filter
+     * @param filters
+     * @param [onlyNew=false] Only subscribe to new events
+     */
+    stream(filters, onlyNew = false) {
+        filters = Array.isArray(filters) ? filters : [filters];
         return new Observable((observer) => {
-            let claimed = new Set();
-            let events = this.database.getForFilters(filters);
-            for (const event of events) {
-                observer.next(event);
-                this.database.claimEvent(event, observer);
-                claimed.add(event);
+            if (!onlyNew) {
+                let events = this.database.getForFilters(filters);
+                for (const event of events)
+                    observer.next(event);
             }
             // subscribe to future events
             const sub = this.database.inserted.subscribe((event) => {
-                if (matchFilters(filters, event)) {
+                if (matchFilters(filters, event))
                     observer.next(event);
-                    this.database.claimEvent(event, observer);
-                    claimed.add(event);
-                }
             });
-            return () => {
-                sub.unsubscribe();
-                // remove all claims
-                for (const event of claimed)
-                    this.database.removeClaim(event, observer);
-                claimed.clear();
-            };
+            return () => sub.unsubscribe();
         });
     }
     /** Creates an observable that updates with an array of sorted events */
-    timeline(filters, keepOldVersions = this.keepOldVersions) {
+    timeline(filters, keepOldVersions = false) {
+        filters = Array.isArray(filters) ? filters : [filters];
         return new Observable((observer) => {
             const seen = new Map();
             const timeline = [];

package/dist/helpers/emoji.d.ts

@@ -1,5 +1,6 @@
 import { EventTemplate, NostrEvent } from "nostr-tools";
-export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: string): ["emoji", string, string];
+/** Gets an "emoji" tag that matches an emoji code */
+export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: string): ["emoji", string, string] | undefined;
 /** Returns the name of a NIP-30 emoji pack */
 export declare function getPackName(pack: NostrEvent): string | undefined;
 /** Returns an array of emojis from a NIP-30 emoji pack */

package/dist/helpers/emoji.js

@@ -1,4 +1,5 @@
 import { getTagValue } from "./event.js";
+/** Gets an "emoji" tag that matches an emoji code */
 export function getEmojiTag(event, code) {
     code = code.replace(/^:|:$/g, "").toLocaleLowerCase();
     return event.tags.filter((t) => t[0] === "emoji" && t[1] && t[2]).find((t) => t[1].toLowerCase() === code);

package/dist/helpers/event.d.ts

@@ -9,6 +9,11 @@ declare module "nostr-tools" {
         [FromCacheSymbol]?: boolean;
     }
 }
+/**
+ * Checks if an object is a nostr event
+ * NOTE: does not validation the signature on the event
+ */
+export declare function isEvent(event: any): event is NostrEvent;
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )

package/dist/helpers/event.js

@@ -4,6 +4,22 @@ import { getHiddenTags } from "./hidden-tags.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
+/**
+ * Checks if an object is a nostr event
+ * NOTE: does not validation the signature on the event
+ */
+export function isEvent(event) {
+    if (event === undefined || event === null)
+        return false;
+    return (event.id?.length === 64 &&
+        typeof event.sig === "string" &&
+        typeof event.pubkey === "string" &&
+        event.pubkey.length === 64 &&
+        typeof event.content === "string" &&
+        Array.isArray(event.tags) &&
+        typeof event.created_at === "number" &&
+        event.created_at > 0);
+}
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )

package/dist/helpers/hidden-tags.d.ts

@@ -1,26 +1,33 @@
 import { EventTemplate, NostrEvent, UnsignedEvent } from "nostr-tools";
 import { EventStore } from "applesauce-core";
 export type HiddenTagsSigner = {
-    nip04: {
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    nip44?: {
         encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     };
 };
 export type TagOperation = (tags: string[][]) => string[][];
 export declare const HiddenTagsSymbol: unique symbol;
-export declare const EventsWithHiddenTags: number[];
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export declare const EventEncryptionMethod: Record<number, "nip04" | "nip44">;
 /** Checks if an event can have hidden tags */
-export declare function canHaveHiddenTags(event: NostrEvent | EventTemplate): boolean;
+export declare function canHaveHiddenTags(kind: number): boolean;
 /** Checks if an event has hidden tags */
 export declare function hasHiddenTags(event: NostrEvent | EventTemplate): boolean;
-/** Returns the hidden tags from an event if they are unlocked */
+/** Returns the hidden tags for an event if they are unlocked */
 export declare function getHiddenTags(event: NostrEvent | EventTemplate): string[][] | undefined;
+/** Checks if the hidden tags are locked */
 export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
  * @param store An optional EventStore to notify about the update
+ * @throws
  */
 export declare function unlockHiddenTags(event: NostrEvent, signer: HiddenTagsSigner, store?: EventStore): Promise<NostrEvent>;
 /**
@@ -28,6 +35,7 @@ export declare function unlockHiddenTags(event: NostrEvent, signer: HiddenTagsSi
  * @param event Event to modify
  * @param operations Operations for hidden and public tags
  * @param signer A signer to use to decrypt the tags
+ * @throws
  */
 export declare function modifyEventTags(event: NostrEvent | UnsignedEvent, operations: {
     public?: TagOperation;
@@ -35,5 +43,6 @@ export declare function modifyEventTags(event: NostrEvent | UnsignedEvent, opera
 }, signer?: HiddenTagsSigner): Promise<EventTemplate>;
 /**
  * Override the hidden tags in an event
+ * @throws
  */
 export declare function overrideHiddenTags(event: NostrEvent, hidden: string[][], signer: HiddenTagsSigner): Promise<EventTemplate>;

package/dist/helpers/hidden-tags.js

@@ -1,47 +1,59 @@
 import { unixNow } from "applesauce-core/helpers";
 import { kinds } from "nostr-tools";
 export const HiddenTagsSymbol = Symbol.for("hidden-tags");
-export const EventsWithHiddenTags = [
-    37375, // NIP-60 wallet
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export const EventEncryptionMethod = {
+    // NIP-60 wallet
+    37375: "nip44",
     // NIP-51 lists
-    kinds.BookmarkList,
-    kinds.InterestsList,
-    kinds.Mutelist,
-    kinds.CommunitiesList,
-    kinds.PublicChatsList,
-    kinds.SearchRelaysList,
-    kinds.SearchRelaysList,
-    10009, // NIP-29 groups
+    [kinds.BookmarkList]: "nip04",
+    [kinds.InterestsList]: "nip04",
+    [kinds.Mutelist]: "nip04",
+    [kinds.CommunitiesList]: "nip04",
+    [kinds.PublicChatsList]: "nip04",
+    [kinds.SearchRelaysList]: "nip04",
     // NIP-51 sets
-    kinds.Bookmarksets,
-    kinds.Relaysets,
-    kinds.Followsets,
-    kinds.Curationsets,
-    kinds.Interestsets,
-];
+    [kinds.Bookmarksets]: "nip04",
+    [kinds.Relaysets]: "nip04",
+    [kinds.Followsets]: "nip04",
+    [kinds.Curationsets]: "nip04",
+    [kinds.Interestsets]: "nip04",
+};
 /** Checks if an event can have hidden tags */
-export function canHaveHiddenTags(event) {
-    return EventsWithHiddenTags.includes(event.kind);
+export function canHaveHiddenTags(kind) {
+    return EventEncryptionMethod[kind] !== undefined;
 }
 /** Checks if an event has hidden tags */
 export function hasHiddenTags(event) {
-    return canHaveHiddenTags(event) && event.content.length > 0;
+    return canHaveHiddenTags(event.kind) && event.content.length > 0;
 }
-/** Returns the hidden tags from an event if they are unlocked */
+/** Returns the hidden tags for an event if they are unlocked */
 export function getHiddenTags(event) {
     return Reflect.get(event, HiddenTagsSymbol);
 }
+/** Checks if the hidden tags are locked */
 export function isHiddenTagsLocked(event) {
     return hasHiddenTags(event) && getHiddenTags(event) === undefined;
 }
+function getEventEncryption(kind, signer) {
+    const method = EventEncryptionMethod[kind];
+    const encryption = signer[method];
+    if (!encryption)
+        throw new Error(`Signer does not support ${method} encryption`);
+    return encryption;
+}
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
  * @param store An optional EventStore to notify about the update
+ * @throws
  */
 export async function unlockHiddenTags(event, signer, store) {
-    const plaintext = await signer.nip04.decrypt(event.pubkey, event.content);
+    if (!canHaveHiddenTags(event.kind))
+        throw new Error("Event kind does not support hidden tags");
+    const encryption = getEventEncryption(event.kind, signer);
+    const plaintext = await encryption.decrypt(event.pubkey, event.content);
     const parsed = JSON.parse(plaintext);
     if (!Array.isArray(parsed))
         throw new Error("Content is not an array of tags");
@@ -57,6 +69,7 @@ export async function unlockHiddenTags(event, signer, store) {
  * @param event Event to modify
  * @param operations Operations for hidden and public tags
  * @param signer A signer to use to decrypt the tags
+ * @throws
  */
 export async function modifyEventTags(event, operations, signer) {
     const draft = { content: event.content, tags: event.tags, kind: event.kind, created_at: unixNow() };
@@ -66,21 +79,26 @@ export async function modifyEventTags(event, operations, signer) {
     if (operations.hidden) {
         if (!signer)
             throw new Error("Missing signer for hidden tags");
-        if (!canHaveHiddenTags(event))
-            throw new Error("Event can not have hidden tags");
+        if (!canHaveHiddenTags(event.kind))
+            throw new Error("Event kind does not support hidden tags");
         const hidden = hasHiddenTags(event) ? getHiddenTags(event) : [];
         if (!hidden)
             throw new Error("Hidden tags are locked");
         const newHidden = operations.hidden(hidden);
-        draft.content = await signer.nip04.encrypt(event.pubkey, JSON.stringify(newHidden));
+        const encryption = getEventEncryption(event.kind, signer);
+        draft.content = await encryption.encrypt(event.pubkey, JSON.stringify(newHidden));
     }
     return draft;
 }
 /**
  * Override the hidden tags in an event
+ * @throws
  */
 export async function overrideHiddenTags(event, hidden, signer) {
-    const ciphertext = await signer.nip04.encrypt(event.pubkey, JSON.stringify(hidden));
+    if (!canHaveHiddenTags(event.kind))
+        throw new Error("Event kind does not support hidden tags");
+    const encryption = getEventEncryption(event.kind, signer);
+    const ciphertext = await encryption.encrypt(event.pubkey, JSON.stringify(hidden));
     return {
         kind: event.kind,
         content: ciphertext,

package/dist/helpers/pointers.d.ts

@@ -1,7 +1,9 @@
 import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
 export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
     identifier?: string;
 };
+/** Parse the value of an "a" tag into an AddressPointer */
 export declare function parseCoordinate(a: string): AddressPointerWithoutD | null;
 export declare function parseCoordinate(a: string, requireD: false): AddressPointerWithoutD | null;
 export declare function parseCoordinate(a: string, requireD: true): AddressPointer | null;
@@ -9,14 +11,25 @@ export declare function parseCoordinate(a: string, requireD: false, silent: fals
 export declare function parseCoordinate(a: string, requireD: true, silent: false): AddressPointer;
 export declare function parseCoordinate(a: string, requireD: true, silent: true): AddressPointer | null;
 export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
+/** Extra a pubkey from the result of nip19.decode */
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
+/** Encodes the result of nip19.decode */
 export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
+/** @throws */
 export declare function getEventPointerFromTag(tag: string[]): EventPointer;
+/** @throws */
 export declare function getAddressPointerFromTag(tag: string[]): AddressPointer;
+/** @throws */
 export declare function getProfilePointerFromTag(tag: string[]): ProfilePointer;
+/** Parses "e", "a", "p", and "q" tags into a pointer */
 export declare function getPointerFromTag(tag: string[]): DecodeResult | null;
 export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
 export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
+/** Returns the coordinate string for an AddressPointer */
 export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
+/** Returns a tag for an address pointer */
 export declare function getATagFromAddressPointer(pointer: AddressPointer): ["a", ...string[]];
+/** Returns a tag for an event pointer */
 export declare function getETagFromEventPointer(pointer: EventPointer): ["e", ...string[]];
+/** Returns a pointer for a given event */
+export declare function getPointerForEvent(event: NostrEvent, relays?: string[]): DecodeResult;

package/dist/helpers/pointers.js

@@ -1,6 +1,7 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
-import { getPublicKey } from "nostr-tools";
+import { getPublicKey, kinds } from "nostr-tools";
 import { safeRelayUrls } from "./relays.js";
+import { getTagValue } from "./index.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] && parseInt(parts[0]);
@@ -30,6 +31,7 @@ export function parseCoordinate(a, requireD = false, silent = true) {
         identifier: d,
     };
 }
+/** Extra a pubkey from the result of nip19.decode */
 export function getPubkeyFromDecodeResult(result) {
     if (!result)
         return;
@@ -45,6 +47,7 @@ export function getPubkeyFromDecodeResult(result) {
             return undefined;
     }
 }
+/** Encodes the result of nip19.decode */
 export function encodeDecodeResult(result) {
     switch (result.type) {
         case "naddr":
@@ -62,14 +65,19 @@ export function encodeDecodeResult(result) {
     }
     return "";
 }
+/** @throws */
 export function getEventPointerFromTag(tag) {
     if (!tag[1])
         throw new Error("Missing event id in tag");
     let pointer = { id: tag[1] };
     if (tag[2])
         pointer.relays = safeRelayUrls([tag[2]]);
+    // get author from NIP-18 quote tags
+    if (tag[0] === "q" && tag[3] && tag[3].length === 64)
+        pointer.author = tag[3];
     return pointer;
 }
+/** @throws */
 export function getAddressPointerFromTag(tag) {
     if (!tag[1])
         throw new Error("Missing coordinate in tag");
@@ -78,6 +86,7 @@ export function getAddressPointerFromTag(tag) {
         pointer.relays = safeRelayUrls([tag[2]]);
     return pointer;
 }
+/** @throws */
 export function getProfilePointerFromTag(tag) {
     if (!tag[1])
         throw new Error("Missing pubkey in tag");
@@ -86,6 +95,7 @@ export function getProfilePointerFromTag(tag) {
         pointer.relays = safeRelayUrls([tag[2]]);
     return pointer;
 }
+/** Parses "e", "a", "p", and "q" tags into a pointer */
 export function getPointerFromTag(tag) {
     try {
         switch (tag[0]) {
@@ -98,6 +108,9 @@ export function getPointerFromTag(tag) {
                 };
             case "p":
                 return { type: "nprofile", data: getProfilePointerFromTag(tag) };
+            // NIP-18 quote tags
+            case "q":
+                return { type: "nevent", data: getEventPointerFromTag(tag) };
         }
     }
     catch (error) { }
@@ -105,21 +118,52 @@ export function getPointerFromTag(tag) {
 }
 export function isAddressPointer(pointer) {
     return (typeof pointer !== "string" &&
-        Object.hasOwn(pointer, "identifier") &&
-        Object.hasOwn(pointer, "pubkey") &&
-        Object.hasOwn(pointer, "kind"));
+        Reflect.has(pointer, "identifier") &&
+        Reflect.has(pointer, "pubkey") &&
+        Reflect.has(pointer, "kind"));
 }
 export function isEventPointer(pointer) {
-    return typeof pointer !== "string" && Object.hasOwn(pointer, "id");
+    return typeof pointer !== "string" && Reflect.has(pointer, "id");
 }
+/** Returns the coordinate string for an AddressPointer */
 export function getCoordinateFromAddressPointer(pointer) {
     return `${pointer.kind}:${pointer.pubkey}:${pointer.identifier}`;
 }
+/** Returns a tag for an address pointer */
 export function getATagFromAddressPointer(pointer) {
     const relay = pointer.relays?.[0];
     const coordinate = getCoordinateFromAddressPointer(pointer);
     return relay ? ["a", coordinate, relay] : ["a", coordinate];
 }
+/** Returns a tag for an event pointer */
 export function getETagFromEventPointer(pointer) {
     return pointer.relays?.length ? ["e", pointer.id, pointer.relays[0]] : ["e", pointer.id];
 }
+/** Returns a pointer for a given event */
+export function getPointerForEvent(event, relays) {
+    if (kinds.isParameterizedReplaceableKind(event.kind)) {
+        const d = getTagValue(event, "d");
+        if (!d)
+            throw new Error("Event missing identifier");
+        return {
+            type: "naddr",
+            data: {
+                identifier: d,
+                kind: event.kind,
+                pubkey: event.pubkey,
+                relays,
+            },
+        };
+    }
+    else {
+        return {
+            type: "nevent",
+            data: {
+                id: event.id,
+                kind: event.kind,
+                author: event.pubkey,
+                relays,
+            },
+        };
+    }
+}

package/dist/helpers/tags.d.ts

@@ -1,6 +1,12 @@
+/** Checks if tag is an "e" tag and has at least one value */
 export declare function isETag(tag: string[]): tag is ["e", string, ...string[]];
+/** Checks if tag is an "p" tag and has at least one value */
 export declare function isPTag(tag: string[]): tag is ["p", string, ...string[]];
+/** Checks if tag is an "r" tag and has at least one value */
 export declare function isRTag(tag: string[]): tag is ["r", string, ...string[]];
+/** Checks if tag is an "d" tag and has at least one value */
 export declare function isDTag(tag: string[]): tag is ["d", string, ...string[]];
+/** Checks if tag is an "a" tag and has at least one value */
 export declare function isATag(tag: string[]): tag is ["a", string, ...string[]];
+/** Checks if tag is an "a" tag and has at least one value */
 export declare function isTTag(tag: string[]): tag is ["t", string, ...string[]];

package/dist/helpers/tags.js

@@ -1,18 +1,24 @@
+/** Checks if tag is an "e" tag and has at least one value */
 export function isETag(tag) {
     return tag[0] === "e" && tag[1] !== undefined;
 }
+/** Checks if tag is an "p" tag and has at least one value */
 export function isPTag(tag) {
     return tag[0] === "p" && tag[1] !== undefined;
 }
+/** Checks if tag is an "r" tag and has at least one value */
 export function isRTag(tag) {
     return tag[0] === "r" && tag[1] !== undefined;
 }
+/** Checks if tag is an "d" tag and has at least one value */
 export function isDTag(tag) {
     return tag[0] === "d" && tag[1] !== undefined;
 }
+/** Checks if tag is an "a" tag and has at least one value */
 export function isATag(tag) {
     return tag[0] === "a" && tag[1] !== undefined;
 }
+/** Checks if tag is an "a" tag and has at least one value */
 export function isTTag(tag) {
     return tag[0] === "a" && tag[1] !== undefined;
 }

package/dist/helpers/url.d.ts

@@ -4,8 +4,11 @@ export declare const IMAGE_EXT: string[];
 export declare const VIDEO_EXT: string[];
 export declare const STREAM_EXT: string[];
 export declare const AUDIO_EXT: string[];
-export declare function isVisualMediaURL(url: string | URL): boolean;
+/** Checks if a url is a image URL */
 export declare function isImageURL(url: string | URL): boolean;
+/** Checks if a url is a video URL */
 export declare function isVideoURL(url: string | URL): boolean;
+/** Checks if a url is a stream URL */
 export declare function isStreamURL(url: string | URL): boolean;
+/** Checks if a url is a audio URL */
 export declare function isAudioURL(url: string | URL): boolean;

package/dist/helpers/url.js

@@ -4,24 +4,25 @@ export const IMAGE_EXT = [".svg", ".gif", ".png", ".jpg", ".jpeg", ".webp", ".av
 export const VIDEO_EXT = [".mp4", ".mkv", ".webm", ".mov"];
 export const STREAM_EXT = [".m3u8"];
 export const AUDIO_EXT = [".mp3", ".wav", ".ogg", ".aac"];
-export function isVisualMediaURL(url) {
-    return isImageURL(url) || isVideoURL(url) || isStreamURL(url);
-}
+/** Checks if a url is a image URL */
 export function isImageURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && IMAGE_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a video URL */
 export function isVideoURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && VIDEO_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a stream URL */
 export function isStreamURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && STREAM_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a audio URL */
 export function isAudioURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);

package/dist/helpers/zap.d.ts

@@ -4,11 +4,28 @@ export declare const ZapFromSymbol: unique symbol;
 export declare const ZapInvoiceSymbol: unique symbol;
 export declare const ZapEventPointerSymbol: unique symbol;
 export declare const ZapAddressPointerSymbol: unique symbol;
+/** Returns the senders pubkey */
 export declare function getZapSender(zap: NostrEvent): string;
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
 export declare function getZapRecipient(zap: NostrEvent): string;
+/** Returns the parsed bolt11 invoice */
 export declare function getZapPayment(zap: NostrEvent): import("./bolt11.js").ParsedInvoice | undefined;
+/** Gets the AddressPointer that was zapped */
 export declare function getZapAddressPointer(zap: NostrEvent): import("nostr-tools/nip19").AddressPointer | null;
+/** Gets the EventPointer that was zapped */
 export declare function getZapEventPointer(zap: NostrEvent): import("nostr-tools/nip19").EventPointer | null;
+/** Gets the preimage for the bolt11 invoice */
 export declare function getZapPreimage(zap: NostrEvent): string | undefined;
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
 export declare function getZapRequest(zap: NostrEvent): import("nostr-tools").Event;
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
 export declare function isValidZap(zap?: NostrEvent): boolean;