applesauce-core 0.9.0 → 0.10.0

package/dist/helpers/zap.js

@@ -2,43 +2,56 @@ import { kinds, nip57 } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getTagValue } from "./event.js";
 import { isATag, isETag } from "./tags.js";
-import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { parseBolt11 } from "./bolt11.js";
 export const ZapRequestSymbol = Symbol.for("zap-request");
 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;
+        return a ? getAddressPointerFromATag(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;
+        return e ? getEventPointerFromETag(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;
@@ -64,3 +81,15 @@ export function isValidZap(zap) {
         return false;
     }
 }
+/** Returns the zap splits for an event */
+export function getZapSplits(event) {
+    const tags = event.tags.filter((t) => t[0] === "zap" && t[1] && t[3]);
+    if (tags.length > 0) {
+        const targets = tags
+            .map((t) => ({ pubkey: t[1], relay: t[2], weight: parseFloat(t[3]) }))
+            .filter((p) => Number.isFinite(p.weight));
+        const total = targets.reduce((v, p) => v + p.weight, 0);
+        return targets.map((p) => ({ ...p, percent: p.weight / total }));
+    }
+    return undefined;
+}

package/dist/observable/{getValue.d.ts → 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/{getValue.js → 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/observable/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./getValue.js";
+export * from "./get-value.js";
 export * from "./share-latest-value.js";

package/dist/observable/index.js

@@ -1,2 +1,2 @@
-export * from "./getValue.js";
+export * from "./get-value.js";
 export * from "./share-latest-value.js";

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/comments.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** Returns all NIP-22 comment replies for the event */
+export declare function CommentsQuery(parent: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/comments.js

@@ -0,0 +1,14 @@
+import { COMMENT_KIND, getEventUID } from "../helpers/index.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+/** Returns all NIP-22 comment replies for the event */
+export function CommentsQuery(parent) {
+    return {
+        key: `${getEventUID(parent)}-comments`,
+        run: (events) => {
+            const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
+            if (isParameterizedReplaceableKind(parent.kind))
+                filter["#a"] = [getEventUID(parent)];
+            return events.timeline(filter);
+        },
+    };
+}

package/dist/queries/index.d.ts

@@ -1,6 +1,7 @@
-export * from "./simple.js";
-export * from "./profile.js";
+export * from "./comments.js";
 export * from "./mailboxes.js";
+export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./simple.js";
 export * from "./thread.js";
 export * from "./zaps.js";

package/dist/queries/index.js

@@ -1,6 +1,7 @@
-export * from "./simple.js";
-export * from "./profile.js";
+export * from "./comments.js";
 export * from "./mailboxes.js";
+export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./simple.js";
 export * from "./thread.js";
 export * from "./zaps.js";

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.d.ts

@@ -1,13 +1,13 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Query } from "../query-store/index.js";
 /** Creates a Query that returns a single event or undefined */
-export declare function SingleEventQuery(uid: string): Query<NostrEvent | undefined>;
+export declare function SingleEventQuery(id: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns a multiple events in a map */
-export declare function MultipleEventsQuery(uids: string[]): Query<Map<string, NostrEvent>>;
+export declare function MultipleEventsQuery(ids: string[]): Query<Map<string, NostrEvent>>;
 /** Creates a Query returning the latest version of a replaceable event */
 export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns an array of sorted events matching the filters */
-export declare function TimelineQuery(filters: Filter | Filter[]): Query<NostrEvent[]>;
+export declare function TimelineQuery(filters: Filter | Filter[], keepOldVersions?: boolean): Query<NostrEvent[]>;
 /** Creates a Query that returns a directory of events by their UID */
 export declare function ReplaceableSetQuery(pointers: {
     kind: number;

package/dist/queries/simple.js

@@ -1,17 +1,17 @@
-import stringify from "json-stringify-deterministic";
+import hash_sum from "hash-sum";
 import { getReplaceableUID } from "../helpers/event.js";
 /** Creates a Query that returns a single event or undefined */
-export function SingleEventQuery(uid) {
+export function SingleEventQuery(id) {
     return {
-        key: uid,
-        run: (events) => events.event(uid),
+        key: id,
+        run: (events) => events.event(id),
     };
 }
 /** Creates a Query that returns a multiple events in a map */
-export function MultipleEventsQuery(uids) {
+export function MultipleEventsQuery(ids) {
     return {
-        key: uids.join(","),
-        run: (events) => events.events(uids),
+        key: ids.join(","),
+        run: (events) => events.events(ids),
     };
 }
 /** Creates a Query returning the latest version of a replaceable event */
@@ -22,17 +22,17 @@ export function ReplaceableQuery(kind, pubkey, d) {
     };
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
-export function TimelineQuery(filters) {
+export function TimelineQuery(filters, keepOldVersions) {
+    filters = Array.isArray(filters) ? filters : [filters];
     return {
-        key: stringify(filters),
-        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
+        key: hash_sum(filters) + (keepOldVersions ? "-history" : ""),
+        run: (events) => events.timeline(filters, keepOldVersions),
     };
 }
 /** Creates a Query that returns a directory of events by their UID */
 export function ReplaceableSetQuery(pointers) {
-    const cords = pointers.map((pointer) => getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
     return {
-        key: stringify(pointers),
-        run: (events) => events.events(cords),
+        key: hash_sum(pointers),
+        run: (events) => events.replaceableSet(pointers),
     };
 }

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, and NIP-22 replies for an event */
+export declare function RepliesQuery(event: NostrEvent, overrideKinds?: number[]): Query<NostrEvent[]>;

package/dist/queries/thread.js

@@ -1,8 +1,10 @@
 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";
+import { COMMENT_KIND } from "../helpers/comment.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
 };
@@ -64,3 +66,27 @@ export function ThreadQuery(root, opts) {
         })),
     };
 }
+/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
+export function RepliesQuery(event, overrideKinds) {
+    return {
+        key: getEventUID(event),
+        run: (events) => {
+            const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
+            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.tags);
+                    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,7 +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>;
@@ -13,35 +21,37 @@ export declare class QueryStore {
     static Queries: typeof Queries;
     store: EventStore;
     constructor(store: EventStore);
-    queries: LRU<Observable<any> | BehaviorSubject<any>>;
+    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 */
-    timeline(filters: Filter | Filter[]): Observable<import("nostr-tools").Event[]>;
-    /** Returns the parsed profile (0) for a pubkey */
+    /** Creates a TimelineQuery */
+    timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<import("nostr-tools").Event[]>;
+    /** 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

@@ -8,53 +8,59 @@ export class QueryStore {
         this.store = store;
     }
     queries = new LRU();
+    observables = new WeakMap();
     /** Creates a cached query */
-    runQuery(queryConstructor) {
-        return (...args) => {
-            const query = queryConstructor(...args);
-            const key = `${queryConstructor.name}|${query.key}`;
-            if (!this.queries.has(key)) {
-                const observable = query.run(this.store, this).pipe(shareLatestValue());
-                this.queries.set(key, observable);
-                return observable;
-            }
-            return this.queries.get(key);
-        };
-    }
-    /** Returns a single event */
+    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);
+    }
+    /** 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 */
-    timeline(filters) {
-        return this.runQuery(Queries.TimelineQuery)(filters);
+    /** Creates a TimelineQuery */
+    timeline(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.9.0",
+  "version": "0.10.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -52,28 +52,20 @@
     }
   },
   "dependencies": {
+    "@scure/base": "^1.1.9",
     "debug": "^4.3.7",
-    "json-stringify-deterministic": "^1.0.12",
+    "fast-deep-equal": "^3.1.3",
+    "hash-sum": "^2.0.0",
     "light-bolt11-decoder": "^3.2.0",
     "nanoid": "^5.0.7",
-    "nostr-tools": "^2.10.1",
+    "nostr-tools": "^2.10.3",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
     "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.13",
-    "jest": "^29.7.0",
-    "jest-extended": "^4.0.2",
-    "typescript": "^5.6.3"
-  },
-  "jest": {
-    "roots": [
-      "dist"
-    ],
-    "setupFilesAfterEnv": [
-      "jest-extended/all"
-    ]
+    "@types/hash-sum": "^1.0.2",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
   },
   "funding": {
     "type": "lightning",
@@ -82,7 +74,7 @@
   "scripts": {
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "watch:test": "(trap 'kill 0' SIGINT; pnpm run build -w > /dev/null & pnpm run test --watch)"
+    "test": "vitest run --passWithNoTests",
+    "watch:test": "vitest"
   }
 }