applesauce-core 0.0.0-next-20250123214405 → 0.0.0-next-20250123215242

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

@@ -0,0 +1,389 @@
+import { kinds } from "nostr-tools";
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { Observable } from "rxjs";
+import { Database } from "./database.js";
+import { getEventUID, getReplaceableUID, getTagValue, isReplaceable } from "../helpers/event.js";
+import { matchFilters } from "../helpers/filter.js";
+import { addSeenRelay } from "../helpers/relays.js";
+import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
+export class EventStore {
+    database;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions = false;
+    constructor() {
+        this.database = new Database();
+    }
+    /** Adds an event to the database and update subscriptions */
+    add(event, fromRelay) {
+        if (event.kind === kinds.EventDeletion)
+            this.handleDeleteEvent(event);
+        // ignore if the event was deleted
+        if (this.checkDeleted(event))
+            return event;
+        // insert event into database
+        const inserted = this.database.addEvent(event);
+        // remove all old version of the replaceable event
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const current = this.database.getReplaceable(event.kind, event.pubkey, getTagValue(event, "d"));
+            if (current) {
+                const older = Array.from(current).filter((e) => e.created_at < event.created_at);
+                for (const old of older)
+                    this.database.deleteEvent(old);
+                // skip inserting this event because its not the newest
+                if (current.length !== older.length)
+                    return current[0];
+            }
+        }
+        // attach relay this event was from
+        if (fromRelay)
+            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) {
+        const ids = getDeleteIds(deleteEvent);
+        for (const id of ids) {
+            this.deletedIds.add(id);
+            // remove deleted events in the database
+            const event = this.database.getEvent(id);
+            if (event)
+                this.database.deleteEvent(event);
+        }
+        const coords = getDeleteCoordinates(deleteEvent);
+        for (const coord of coords) {
+            this.deletedCoords.set(coord, Math.max(this.deletedCoords.get(coord) ?? 0, deleteEvent.created_at));
+            // remove deleted events in the database
+            const event = this.database.getEvent(coord);
+            if (event && event.created_at < deleteEvent.created_at)
+                this.database.deleteEvent(event);
+        }
+    }
+    checkDeleted(event) {
+        if (this.deletedIds.has(event.id))
+            return true;
+        if (isParameterizedReplaceableKind(event.kind)) {
+            const deleted = this.deletedCoords.get(getEventUID(event));
+            if (deleted)
+                return deleted > event.created_at;
+        }
+        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);
+    }
+    getAll(filters) {
+        return this.database.getForFilters(filters);
+    }
+    hasEvent(uid) {
+        return this.database.hasEvent(uid);
+    }
+    getEvent(uid) {
+        return this.database.getEvent(uid);
+    }
+    hasReplaceable(kind, pubkey, d) {
+        return this.database.hasReplaceable(kind, pubkey, d);
+    }
+    /** Gets the latest version of a replaceable event */
+    getReplaceable(kind, pubkey, d) {
+        return this.database.getReplaceable(kind, pubkey, d)?.[0];
+    }
+    /** Returns all versions of a replaceable event */
+    getReplaceableHistory(kind, pubkey, d) {
+        return this.database.getReplaceable(kind, pubkey, d);
+    }
+    /** Creates an observable that updates a single event */
+    event(id) {
+        return new Observable((observer) => {
+            let current = this.database.getEvent(id);
+            if (current) {
+                observer.next(current);
+                this.database.claimEvent(current, observer);
+            }
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                if (event.id === id) {
+                    current = event;
+                    observer.next(event);
+                    this.database.claimEvent(event, observer);
+                }
+            });
+            // subscribe to updated events
+            const updated = this.database.updated.subscribe((event) => {
+                if (event.id === id)
+                    observer.next(current);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                if (current?.id === event.id) {
+                    this.database.removeClaim(current, observer);
+                    current = undefined;
+                    observer.next(undefined);
+                }
+            });
+            return () => {
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                inserted.unsubscribe();
+                if (current)
+                    this.database.removeClaim(current, observer);
+            };
+        });
+    }
+    /** Creates an observable that subscribes to multiple events */
+    events(ids) {
+        return new Observable((observer) => {
+            let events = {};
+            for (const id of ids) {
+                const event = this.getEvent(id);
+                if (event) {
+                    events = { ...events, [id]: event };
+                    this.database.claimEvent(event, observer);
+                }
+            }
+            observer.next(events);
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                const id = event.id;
+                if (ids.includes(id) && !events[id]) {
+                    events = { ...events, [id]: event };
+                    observer.next(events);
+                    // claim new event
+                    this.database.claimEvent(event, observer);
+                }
+            });
+            // subscribe to updated events
+            const updated = this.database.updated.subscribe((event) => {
+                if (ids.includes(event.id))
+                    observer.next(events);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                const id = event.id;
+                if (ids.includes(id)) {
+                    const current = events[id];
+                    if (current) {
+                        this.database.removeClaim(current, observer);
+                        delete events[id];
+                        observer.next(events);
+                    }
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                for (const [_uid, event] of Object.entries(events)) {
+                    this.database.removeClaim(event, observer);
+                }
+            };
+        });
+    }
+    /** Creates an observable with the latest version of a replaceable event */
+    replaceable(kind, pubkey, d) {
+        return new Observable((observer) => {
+            const uid = getReplaceableUID(kind, pubkey, d);
+            // get latest version
+            let current = this.database.getReplaceable(kind, pubkey, d)?.[0];
+            if (current) {
+                observer.next(current);
+                this.database.claimEvent(current, observer);
+            }
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                if (getEventUID(event) === uid && (!current || event.created_at > current.created_at)) {
+                    // remove old claim
+                    if (current)
+                        this.database.removeClaim(current, observer);
+                    current = event;
+                    observer.next(event);
+                    // claim new event
+                    this.database.claimEvent(current, observer);
+                }
+            });
+            // subscribe to updated events
+            const updated = this.database.updated.subscribe((event) => {
+                if (event === current)
+                    observer.next(event);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                if (getEventUID(event) === uid && event === current) {
+                    this.database.removeClaim(current, observer);
+                    current = undefined;
+                    observer.next(undefined);
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                if (current)
+                    this.database.removeClaim(current, observer);
+            };
+        });
+    }
+    /** Creates an observable with the latest versions of replaceable events */
+    replaceableSet(pointers) {
+        return new Observable((observer) => {
+            const coords = pointers.map((p) => getReplaceableUID(p.kind, p.pubkey, p.identifier));
+            let events = {};
+            const handleEvent = (event) => {
+                const uid = getEventUID(event);
+                const current = events[uid];
+                if (current) {
+                    if (event.created_at > current.created_at) {
+                        this.database.removeClaim(current, observer);
+                    }
+                    else
+                        return;
+                }
+                events = { ...events, [uid]: event };
+                this.database.claimEvent(event, observer);
+            };
+            // get latest version
+            for (const pointer of pointers) {
+                const events = this.database.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
+                if (events)
+                    handleEvent(events[0]);
+            }
+            observer.next(events);
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                if (isReplaceable(event.kind) && coords.includes(getEventUID(event))) {
+                    handleEvent(event);
+                    observer.next(events);
+                }
+            });
+            // subscribe to updated events
+            const updated = this.database.updated.subscribe((event) => {
+                if (isReplaceable(event.kind) && coords.includes(getEventUID(event))) {
+                    observer.next(events);
+                }
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                const uid = getEventUID(event);
+                if (events[uid]) {
+                    delete events[uid];
+                    this.database.removeClaim(event, observer);
+                    observer.next(events);
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                for (const [_id, event] of Object.entries(events)) {
+                    this.database.removeClaim(event, observer);
+                }
+            };
+        });
+    }
+    /**
+     * 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) => {
+            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))
+                    observer.next(event);
+            });
+            return () => sub.unsubscribe();
+        });
+    }
+    /** Creates an observable that updates with an array of sorted events */
+    timeline(filters, keepOldVersions = false) {
+        filters = Array.isArray(filters) ? filters : [filters];
+        return new Observable((observer) => {
+            const seen = new Map();
+            const timeline = [];
+            // NOTE: only call this if we know the event is in timeline
+            const removeFromTimeline = (event) => {
+                timeline.splice(timeline.indexOf(event), 1);
+                if (!keepOldVersions && isReplaceable(event.kind))
+                    seen.delete(getEventUID(event));
+                this.database.removeClaim(event, observer);
+            };
+            // inserts an event into the timeline and handles replaceable events
+            const insertIntoTimeline = (event) => {
+                // remove old versions
+                if (!keepOldVersions && isReplaceable(event.kind)) {
+                    const uid = getEventUID(event);
+                    const old = seen.get(uid);
+                    if (old) {
+                        if (event.created_at > old.created_at)
+                            removeFromTimeline(old);
+                        else
+                            return;
+                    }
+                    seen.set(uid, event);
+                }
+                // insert into timeline
+                insertEventIntoDescendingList(timeline, event);
+                this.database.claimEvent(event, observer);
+            };
+            // build initial timeline
+            const events = this.database.getForFilters(filters);
+            for (const event of events)
+                insertIntoTimeline(event);
+            observer.next([...timeline]);
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                if (matchFilters(filters, event)) {
+                    insertIntoTimeline(event);
+                    observer.next([...timeline]);
+                }
+            });
+            // subscribe to updated events
+            const updated = this.database.updated.subscribe((event) => {
+                if (timeline.includes(event)) {
+                    observer.next([...timeline]);
+                }
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                if (timeline.includes(event)) {
+                    removeFromTimeline(event);
+                    observer.next([...timeline]);
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                // remove all claims
+                for (const event of timeline) {
+                    this.database.removeClaim(event, observer);
+                }
+                // forget seen replaceable events
+                seen.clear();
+            };
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./event-store.js";
+export * from "./database.js";

package/dist/event-store/index.js

@@ -0,0 +1,2 @@
+export * from "./event-store.js";
+export * from "./database.js";

package/dist/helpers/bolt11.d.ts

@@ -0,0 +1,9 @@
+export type ParsedInvoice = {
+    paymentRequest: string;
+    description: string;
+    amount?: number;
+    timestamp: number;
+    expiry: number;
+};
+/** Parses a lightning invoice */
+export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -0,0 +1,15 @@
+import { decode } from "light-bolt11-decoder";
+/** Parses a lightning invoice */
+export function parseBolt11(paymentRequest) {
+    const decoded = decode(paymentRequest);
+    const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;
+    const description = decoded.sections.find((s) => s.name === "description")?.value ?? "";
+    const amount = parseInt(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
+    return {
+        paymentRequest: decoded.paymentRequest,
+        description: description,
+        amount: amount,
+        timestamp: timestamp,
+        expiry: timestamp + decoded.expiry,
+    };
+}

package/dist/helpers/cache.d.ts

@@ -0,0 +1,5 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+export declare function getCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol): T | undefined;
+export declare function setCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, value: T): void;
+/** Internal method used to cache computed values on events */
+export declare function getOrComputeCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, compute: (event: NostrEvent | EventTemplate) => T): T;

package/dist/helpers/cache.js

@@ -0,0 +1,17 @@
+export function getCachedValue(event, symbol) {
+    return Reflect.get(event, symbol);
+}
+export function setCachedValue(event, symbol, value) {
+    Reflect.set(event, symbol, value);
+}
+/** Internal method used to cache computed values on events */
+export function getOrComputeCachedValue(event, symbol, compute) {
+    if (Reflect.has(event, symbol)) {
+        return Reflect.get(event, symbol);
+    }
+    else {
+        const value = compute(event);
+        Reflect.set(event, symbol, value);
+        return value;
+    }
+}

package/dist/helpers/comment.d.ts

@@ -0,0 +1,47 @@
+import { NostrEvent } from "nostr-tools";
+import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
+export declare const COMMENT_KIND = 1111;
+export type CommentEventPointer = {
+    id: string;
+    kind: number;
+    pubkey?: string;
+    relay?: string;
+};
+export type CommentAddressPointer = {
+    id?: string;
+    kind: number;
+    pubkey: string;
+    identifier: string;
+    relay?: string;
+};
+export type CommentExternalPointer = ExternalPointer<keyof ExternalIdentifiers>;
+export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer;
+export declare const CommentRootPointerSymbol: unique symbol;
+export declare const CommentReplyPointerSymbol: unique symbol;
+/**
+ * Gets the EventPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentEventPointer(tags: string[][], root?: boolean): CommentEventPointer | null;
+/**
+ * Gets the AddressPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentAddressPointer(tags: string[][], root?: boolean): CommentAddressPointer | null;
+/**
+ * Gets the ExternalPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer | null;
+/**
+ * Returns the root pointer for a comment
+ * @throws
+ */
+export declare function getCommentRootPointer(comment: NostrEvent): CommentPointer | null;
+/**
+ * Returns the reply pointer for a comment
+ * @throws
+ */
+export declare function getCommentReplyPointer(comment: NostrEvent): CommentPointer | null;
+export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
+export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;

package/dist/helpers/comment.js

@@ -0,0 +1,116 @@
+import { getExternalPointerFromTag } from "./external-id.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+import { safeRelayUrl } 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
+ */
+export function getCommentEventPointer(tags, root = false) {
+    const tag = tags.find((t) => t[0] === (root ? "E" : "e"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (tag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        const pointer = {
+            id: tag[1],
+            kind: parseInt(kind),
+            pubkey: tag[3] || undefined,
+            relay: tag[2] && (safeRelayUrl(tag[2]) ?? undefined),
+        };
+        return pointer;
+    }
+    return null;
+}
+/**
+ * Gets the AddressPointer from an array of tags
+ * @throws
+ */
+export function getCommentAddressPointer(tags, root = false) {
+    const tag = tags.find((t) => t[0] === (root ? "A" : "a"));
+    const id = tags.find((t) => t[0] === (root ? "E" : "e"))?.[1];
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (tag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        const pointer = {
+            id,
+            ...getAddressPointerFromATag(tag),
+            kind: parseInt(kind),
+        };
+        return pointer;
+    }
+    return null;
+}
+/**
+ * Gets the ExternalPointer from an array of tags
+ * @throws
+ */
+export function getCommentExternalPointer(tags, root = false) {
+    const tag = tags.find((t) => t[0] === (root ? "I" : "i"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (tag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        const pointer = getExternalPointerFromTag(tag);
+        return pointer;
+    }
+    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 getOrComputeCachedValue(comment, CommentRootPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, true);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, true);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, true);
+        if (I)
+            return I;
+        return null;
+    });
+}
+/**
+ * Returns the reply pointer for a comment
+ * @throws
+ */
+export function getCommentReplyPointer(comment) {
+    if (comment.kind !== COMMENT_KIND)
+        throw new Error("Event is not a comment");
+    return getOrComputeCachedValue(comment, CommentReplyPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, false);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, false);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, false);
+        if (I)
+            return I;
+        return null;
+    });
+}
+export function isCommentEventPointer(pointer) {
+    return (Reflect.has(pointer, "id") &&
+        Reflect.has(pointer, "kind") &&
+        !Reflect.has(pointer, "identifier") &&
+        typeof pointer.kind === "number");
+}
+export function isCommentAddressPointer(pointer) {
+    return (Reflect.has(pointer, "identifier") &&
+        Reflect.has(pointer, "pubkey") &&
+        Reflect.has(pointer, "kind") &&
+        typeof pointer.kind === "number");
+}

package/dist/helpers/content.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export declare function getContentWarning(event: NostrEvent): string | boolean;

package/dist/helpers/content.js

@@ -0,0 +1,8 @@
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export function getContentWarning(event) {
+    const tag = event.tags.find((t) => t[0] === "content-warning");
+    if (tag)
+        return tag[1] || true;
+    else
+        return false;
+}

package/dist/helpers/delete.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+export declare function getDeleteIds(deleteEvent: NostrEvent): string[];
+export declare function getDeleteCoordinates(deleteEvent: NostrEvent): string[];

package/dist/helpers/delete.js

@@ -0,0 +1,7 @@
+import { isATag, isETag } from "./tags.js";
+export function getDeleteIds(deleteEvent) {
+    return deleteEvent.tags.filter(isETag).map((t) => t[1]);
+}
+export function getDeleteCoordinates(deleteEvent) {
+    return deleteEvent.tags.filter(isATag).map((t) => t[1]);
+}

package/dist/helpers/emoji.d.ts

@@ -0,0 +1,11 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+/** 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;
+export type Emoji = {
+    name: string;
+    url: string;
+};
+/** Returns an array of emojis from a NIP-30 emoji pack */
+export declare function getEmojis(pack: NostrEvent): Emoji[];

package/dist/helpers/emoji.js

@@ -0,0 +1,16 @@
+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);
+}
+/** Returns the name of a NIP-30 emoji pack */
+export function getPackName(pack) {
+    return getTagValue(pack, "title") || getTagValue(pack, "d");
+}
+/** Returns an array of emojis from a NIP-30 emoji pack */
+export function getEmojis(pack) {
+    return pack.tags
+        .filter((t) => t[0] === "emoji" && t[1] && t[2])
+        .map((t) => ({ name: t[1], url: t[2] }));
+}