applesauce-core 0.0.0-next-20241204152949 → 0.0.0-next-20241207161834

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

@@ -15,13 +15,17 @@ export declare function parseCoordinate(a: string, requireD: false, silent: true
 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 a tag into a pointer */
+/** 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[]];

package/dist/helpers/pointers.js

@@ -65,6 +65,7 @@ export function encodeDecodeResult(result) {
     }
     return "";
 }
+/** @throws */
 export function getEventPointerFromTag(tag) {
     if (!tag[1])
         throw new Error("Missing event id in tag");
@@ -76,6 +77,7 @@ export function getEventPointerFromTag(tag) {
         pointer.author = tag[3];
     return pointer;
 }
+/** @throws */
 export function getAddressPointerFromTag(tag) {
     if (!tag[1])
         throw new Error("Missing coordinate in tag");
@@ -84,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");
@@ -92,7 +95,7 @@ export function getProfilePointerFromTag(tag) {
         pointer.relays = safeRelayUrls([tag[2]]);
     return pointer;
 }
-/** Parses a tag into a pointer */
+/** Parses "e", "a", "p", and "q" tags into a pointer */
 export function getPointerFromTag(tag) {
     try {
         switch (tag[0]) {
@@ -115,13 +118,14 @@ 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}`;
 }

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;

package/dist/helpers/zap.js

@@ -9,36 +9,49 @@ export const ZapFromSymbol = Symbol.for("zap-from");
 export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
 export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
 export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
+/** Returns the senders pubkey */
 export function getZapSender(zap) {
     return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
 }
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
 export function getZapRecipient(zap) {
     const recipient = getTagValue(zap, "p");
     if (!recipient)
         throw new Error("Missing recipient");
     return recipient;
 }
+/** Returns the parsed bolt11 invoice */
 export function getZapPayment(zap) {
     return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
         const bolt11 = getTagValue(zap, "bolt11");
         return bolt11 ? parseBolt11(bolt11) : undefined;
     });
 }
+/** Gets the AddressPointer that was zapped */
 export function getZapAddressPointer(zap) {
     return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
         const a = zap.tags.find(isATag);
         return a ? getAddressPointerFromTag(a) : null;
     });
 }
+/** Gets the EventPointer that was zapped */
 export function getZapEventPointer(zap) {
     return getOrComputeCachedValue(zap, ZapEventPointerSymbol, () => {
         const e = zap.tags.find(isETag);
         return e ? getEventPointerFromTag(e) : null;
     });
 }
+/** Gets the preimage for the bolt11 invoice */
 export function getZapPreimage(zap) {
     return getTagValue(zap, "preimage");
 }
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
 export function getZapRequest(zap) {
     return getOrComputeCachedValue(zap, ZapRequestSymbol, () => {
         const description = getTagValue(zap, "description");
@@ -50,6 +63,10 @@ export function getZapRequest(zap) {
         return JSON.parse(description);
     });
 }
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
 export function isValidZap(zap) {
     if (!zap)
         return false;

package/dist/observable/get-value.d.ts

@@ -1,2 +1,3 @@
 import { Observable } from "rxjs";
+/** Subscribes and returns the observables current or next value */
 export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/get-value.js

@@ -1,4 +1,5 @@
 import { BehaviorSubject } from "rxjs";
+/** Subscribes and returns the observables current or next value */
 export function getValue(observable) {
     if (observable instanceof BehaviorSubject)
         return observable.value;

package/dist/promise/deferred.d.ts

@@ -2,4 +2,5 @@ export type Deferred<T> = Promise<T> & {
     resolve: (value?: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
 };
+/** Creates a controlled promise */
 export declare function createDefer<T>(): Deferred<T>;

package/dist/promise/deferred.js

@@ -1,3 +1,4 @@
+/** Creates a controlled promise */
 export function createDefer() {
     let _resolve;
     let _reject;

package/dist/queries/mailboxes.d.ts

@@ -1,4 +1,5 @@
 import { Query } from "../query-store/index.js";
+/** A query that gets and parses the inbox and outbox relays for a pubkey */
 export declare function MailboxesQuery(pubkey: string): Query<{
     inboxes: string[];
     outboxes: string[];

package/dist/queries/mailboxes.js

@@ -1,6 +1,7 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+/** A query that gets and parses the inbox and outbox relays for a pubkey */
 export function MailboxesQuery(pubkey) {
     return {
         key: pubkey,

package/dist/queries/profile.d.ts

@@ -1,3 +1,4 @@
 import { ProfileContent } from "../helpers/profile.js";
 import { Query } from "../query-store/index.js";
+/** A query that gets and parses the kind 0 metadata for a pubkey */
 export declare function ProfileQuery(pubkey: string): Query<ProfileContent | undefined>;

package/dist/queries/profile.js

@@ -1,6 +1,7 @@
 import { kinds } from "nostr-tools";
 import { filter, map } from "rxjs/operators";
 import { getProfileContent, isValidProfile } from "../helpers/profile.js";
+/** A query that gets and parses the kind 0 metadata for a pubkey */
 export function ProfileQuery(pubkey) {
     return {
         key: pubkey,

package/dist/queries/reactions.d.ts

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

package/dist/queries/reactions.js

@@ -1,6 +1,6 @@
 import { kinds } from "nostr-tools";
 import { getEventUID, isReplaceable } from "../helpers/event.js";
-/** Creates a query that returns all reactions to an event (supports replaceable events) */
+/** A query that returns all reactions to an event (supports replaceable events) */
 export function ReactionsQuery(event) {
     return {
         key: getEventUID(event),

package/dist/queries/simple.js

@@ -36,5 +36,3 @@ export function ReplaceableSetQuery(pointers) {
         run: (events) => events.replaceableSet(pointers),
     };
 }
-// @ts-expect-error
-window.hash_sum = hash_sum;

package/dist/queries/thread.d.ts

@@ -21,3 +21,5 @@ export type ThreadQueryOptions = {
     kinds?: number[];
 };
 export declare function ThreadQuery(root: string | AddressPointer | EventPointer, opts?: ThreadQueryOptions): Query<Thread>;
+/** A query that gets all legacy and NIP-10 replies for an event */
+export declare function RepliesQuery(event: NostrEvent, overrideKinds?: number[]): Query<NostrEvent[]>;

package/dist/queries/thread.js

@@ -1,8 +1,9 @@
 import { kinds } from "nostr-tools";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 import { map } from "rxjs/operators";
-import { getNip10References } from "../helpers/threading.js";
-import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
-import { getEventUID } from "../helpers/event.js";
+import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
+import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer } from "../helpers/pointers.js";
+import { getEventUID, getReplaceableUID, getTagValue, isEvent } from "../helpers/event.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
 };
@@ -64,3 +65,27 @@ export function ThreadQuery(root, opts) {
         })),
     };
 }
+/** A query that gets all legacy and NIP-10 replies for an event */
+export function RepliesQuery(event, overrideKinds) {
+    return {
+        key: getEventUID(event),
+        run: (events) => {
+            const kinds = overrideKinds || event.kind === 1 ? [1, 1111] : [1111];
+            const filter = { kinds };
+            if (isEvent(parent) || isEventPointer(event))
+                filter["#e"] = [event.id];
+            const address = isParameterizedReplaceableKind(event.kind)
+                ? getReplaceableUID(event.kind, event.pubkey, getTagValue(event, "d"))
+                : undefined;
+            if (address) {
+                filter["#a"] = [address];
+            }
+            return events.timeline(filter).pipe(map((events) => {
+                return events.filter((e) => {
+                    const refs = interpretThreadTags(e);
+                    return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
+                });
+            }));
+        },
+    };
+}

package/dist/queries/zaps.d.ts

@@ -1,4 +1,5 @@
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { NostrEvent } from "nostr-tools";
 import { Query } from "../query-store/index.js";
+/** A query that gets all zap events for an event */
 export declare function EventZapsQuery(id: string | EventPointer | AddressPointer): Query<NostrEvent[]>;

package/dist/queries/zaps.js

@@ -2,6 +2,7 @@ import { map } from "rxjs";
 import { kinds } from "nostr-tools";
 import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
 import { isValidZap } from "../helpers/zap.js";
+/** A query that gets all zap events for an event */
 export function EventZapsQuery(id) {
     return {
         key: JSON.stringify(id),

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

@@ -5,8 +5,15 @@ import { LRU } from "../helpers/lru.js";
 import * as Queries from "../queries/index.js";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 export type Query<T extends unknown> = {
+    /**
+     * A unique key for this query. this is used to detect duplicate queries
+     */
     key: string;
+    /** The args array this query was created with. This is mostly for debugging */
     args?: Array<any>;
+    /**
+     * The meat of the query, this should return an Observables that subscribes to the eventStore in some way
+     */
     run: (events: EventStore, store: QueryStore) => Observable<T>;
 };
 export type QueryConstructor<T extends unknown, Args extends Array<any>> = (...args: Args) => Query<T>;
@@ -17,33 +24,34 @@ export declare class QueryStore {
     queries: LRU<Query<any>>;
     observables: WeakMap<Query<any>, Observable<any> | BehaviorSubject<any>>;
     /** Creates a cached query */
-    runQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
+    createQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
         key: string;
         run: (events: EventStore, store: QueryStore) => Observable<T>;
-    }): (...args: Args) => Observable<T>;
-    /** Returns a single event */
+    }, ...args: Args): Observable<T>;
+    /** Creates a SingleEventQuery */
     event(id: string): Observable<import("nostr-tools").Event | undefined>;
-    /** Returns a single event */
+    /** Creates a MultipleEventsQuery */
     events(ids: string[]): Observable<Map<string, import("nostr-tools").Event>>;
-    /** Returns the latest version of a replaceable event */
+    /** Creates a ReplaceableQuery */
     replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
-    /** Returns a directory of events by their UID */
+    /** Creates a ReplaceableSetQuery */
     replaceableSet(pointers: {
         kind: number;
         pubkey: string;
         identifier?: string;
     }[]): Observable<Map<string, import("nostr-tools").Event>>;
-    /** Returns an array of events that match the filter */
+    /** Creates a TimelineQuery */
     timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<import("nostr-tools").Event[]>;
-    /** Returns the parsed profile (0) for a pubkey */
+    /** Creates a ProfileQuery */
     profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-    /** Returns all reactions for an event (supports replaceable events) */
+    /** Creates a ReactionsQuery */
     reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** Returns the parsed relay list (10002) for the pubkey */
+    /** Creates a MailboxesQuery */
     mailboxes(pubkey: string): Observable<{
         inboxes: string[];
         outboxes: string[];
     } | undefined>;
+    /** Creates a ThreadQuery */
     thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
 }
 export { Queries };

package/dist/query-store/index.js

@@ -10,58 +10,57 @@ export class QueryStore {
     queries = new LRU();
     observables = new WeakMap();
     /** Creates a cached query */
-    runQuery(queryConstructor) {
-        return (...args) => {
-            const tempQuery = queryConstructor(...args);
-            const key = `${queryConstructor.name}|${tempQuery.key}`;
-            let query = this.queries.get(key);
-            if (!query) {
-                query = tempQuery;
-                this.queries.set(key, tempQuery);
-            }
-            if (!this.observables.has(query)) {
-                query.args = args;
-                const observable = query.run(this.store, this).pipe(shareLatestValue());
-                this.observables.set(query, observable);
-                return observable;
-            }
-            return this.observables.get(query);
-        };
+    createQuery(queryConstructor, ...args) {
+        const tempQuery = queryConstructor(...args);
+        const key = `${queryConstructor.name}|${tempQuery.key}`;
+        let query = this.queries.get(key);
+        if (!query) {
+            query = tempQuery;
+            this.queries.set(key, tempQuery);
+        }
+        if (!this.observables.has(query)) {
+            query.args = args;
+            const observable = query.run(this.store, this).pipe(shareLatestValue());
+            this.observables.set(query, observable);
+            return observable;
+        }
+        return this.observables.get(query);
     }
-    /** Returns a single event */
+    /** Creates a SingleEventQuery */
     event(id) {
-        return this.runQuery(Queries.SingleEventQuery)(id);
+        return this.createQuery(Queries.SingleEventQuery, id);
     }
-    /** Returns a single event */
+    /** Creates a MultipleEventsQuery */
     events(ids) {
-        return this.runQuery(Queries.MultipleEventsQuery)(ids);
+        return this.createQuery(Queries.MultipleEventsQuery, ids);
     }
-    /** Returns the latest version of a replaceable event */
+    /** Creates a ReplaceableQuery */
     replaceable(kind, pubkey, d) {
-        return this.runQuery(Queries.ReplaceableQuery)(kind, pubkey, d);
+        return this.createQuery(Queries.ReplaceableQuery, kind, pubkey, d);
     }
-    /** Returns a directory of events by their UID */
+    /** Creates a ReplaceableSetQuery */
     replaceableSet(pointers) {
-        return this.runQuery(Queries.ReplaceableSetQuery)(pointers);
+        return this.createQuery(Queries.ReplaceableSetQuery, pointers);
     }
-    /** Returns an array of events that match the filter */
+    /** Creates a TimelineQuery */
     timeline(filters, keepOldVersions) {
-        return this.runQuery(Queries.TimelineQuery)(filters, keepOldVersions);
+        return this.createQuery(Queries.TimelineQuery, filters, keepOldVersions);
     }
-    /** Returns the parsed profile (0) for a pubkey */
+    /** Creates a ProfileQuery */
     profile(pubkey) {
-        return this.runQuery(Queries.ProfileQuery)(pubkey);
+        return this.createQuery(Queries.ProfileQuery, pubkey);
     }
-    /** Returns all reactions for an event (supports replaceable events) */
+    /** Creates a ReactionsQuery */
     reactions(event) {
-        return this.runQuery(Queries.ReactionsQuery)(event);
+        return this.createQuery(Queries.ReactionsQuery, event);
     }
-    /** Returns the parsed relay list (10002) for the pubkey */
+    /** Creates a MailboxesQuery */
     mailboxes(pubkey) {
-        return this.runQuery(Queries.MailboxesQuery)(pubkey);
+        return this.createQuery(Queries.MailboxesQuery, pubkey);
     }
+    /** Creates a ThreadQuery */
     thread(root) {
-        return this.runQuery(Queries.ThreadQuery)(root);
+        return this.createQuery(Queries.ThreadQuery, root);
     }
 }
 export { Queries };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20241204152949",
+  "version": "0.0.0-next-20241207161834",
   "description": "",
   "type": "module",
   "main": "dist/index.js",