applesauce-core 0.0.0-next-20250120191411 → 0.0.0-next-20250123214405

package/dist/queries/simple.js

@@ -1,38 +0,0 @@
-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(id) {
-    return {
-        key: id,
-        run: (events) => events.event(id),
-    };
-}
-/** Creates a Query that returns a multiple events in a map */
-export function MultipleEventsQuery(ids) {
-    return {
-        key: ids.join(","),
-        run: (events) => events.events(ids),
-    };
-}
-/** Creates a Query returning the latest version of a replaceable event */
-export function ReplaceableQuery(kind, pubkey, d) {
-    return {
-        key: getReplaceableUID(kind, pubkey, d),
-        run: (events) => events.replaceable(kind, pubkey, d),
-    };
-}
-/** Creates a Query that returns an array of sorted events matching the filters */
-export function TimelineQuery(filters, keepOldVersions) {
-    filters = Array.isArray(filters) ? filters : [filters];
-    return {
-        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) {
-    return {
-        key: hash_sum(pointers),
-        run: (events) => events.replaceableSet(pointers),
-    };
-}

package/dist/queries/thread.d.ts

@@ -1,25 +0,0 @@
-import { NostrEvent } from "nostr-tools";
-import { AddressPointer, EventPointer } from "nostr-tools/nip19";
-import { Query } from "../query-store/index.js";
-import { ThreadReferences } from "../helpers/threading.js";
-export type Thread = {
-    root?: ThreadItem;
-    all: Map<string, ThreadItem>;
-};
-export type ThreadItem = {
-    /** underlying nostr event */
-    event: NostrEvent;
-    refs: ThreadReferences;
-    /** the thread root, according to this event */
-    root?: ThreadItem;
-    /** the parent event this is replying to */
-    parent?: ThreadItem;
-    /** direct child replies */
-    replies: Set<ThreadItem>;
-};
-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,92 +0,0 @@
-import { kinds } from "nostr-tools";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
-import { map } from "rxjs/operators";
-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],
-};
-export function ThreadQuery(root, opts) {
-    const parentReferences = new Map();
-    const items = new Map();
-    const { kinds } = { ...defaultOptions, ...opts };
-    let rootUID = "";
-    const rootFilter = {};
-    const replyFilter = { kinds };
-    if (isAddressPointer(root)) {
-        rootUID = getCoordinateFromAddressPointer(root);
-        rootFilter.kinds = [root.kind];
-        rootFilter.authors = [root.pubkey];
-        rootFilter["#d"] = [root.identifier];
-        replyFilter["#a"] = [rootUID];
-    }
-    else if (typeof root === "string") {
-        rootUID = root;
-        rootFilter.ids = [root];
-        replyFilter["#e"] = [root];
-    }
-    else {
-        rootUID = root.id;
-        rootFilter.ids = [root.id];
-        replyFilter["#e"] = [root.id];
-    }
-    return {
-        key: `${rootUID}-${kinds.join(",")}`,
-        run: (events) => events.stream([rootFilter, replyFilter]).pipe(map((event) => {
-            if (!items.has(getEventUID(event))) {
-                const refs = getNip10References(event);
-                const replies = parentReferences.get(getEventUID(event)) || new Set();
-                const item = { event, refs, replies };
-                for (const child of replies) {
-                    child.parent = item;
-                }
-                // add item to parent
-                if (refs.reply?.e || refs.reply?.a) {
-                    let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
-                    item.parent = items.get(uid);
-                    if (item.parent) {
-                        item.parent.replies.add(item);
-                    }
-                    else {
-                        // parent isn't created yet, store ref for later
-                        let set = parentReferences.get(uid);
-                        if (!set) {
-                            set = new Set();
-                            parentReferences.set(uid, set);
-                        }
-                        set.add(item);
-                    }
-                }
-                // add item to map
-                items.set(getEventUID(event), item);
-            }
-            return { root: items.get(rootUID), all: items };
-        })),
-    };
-}
-/** 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,5 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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),
-        run: (events) => {
-            if (isAddressPointer(id)) {
-                return events
-                    .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
-                    .pipe(map((events) => events.filter(isValidZap)));
-            }
-            else {
-                id = typeof id === "string" ? id : id.id;
-                return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
-            }
-        },
-    };
-}

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

@@ -1,57 +0,0 @@
-import { BehaviorSubject, Observable } from "rxjs";
-import { Filter, NostrEvent } from "nostr-tools";
-import { EventStore } from "../event-store/event-store.js";
-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>;
-export declare class QueryStore {
-    static Queries: typeof Queries;
-    store: EventStore;
-    constructor(store: EventStore);
-    queries: LRU<Query<any>>;
-    observables: WeakMap<Query<any>, Observable<any> | BehaviorSubject<any>>;
-    /** Creates a cached query */
-    createQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
-        key: string;
-        run: (events: EventStore, store: QueryStore) => Observable<T>;
-    }, ...args: Args): Observable<T>;
-    /** Creates a SingleEventQuery */
-    event(id: string): Observable<import("nostr-tools").Event | undefined>;
-    /** Creates a MultipleEventsQuery */
-    events(ids: string[]): Observable<Record<string, import("nostr-tools").Event>>;
-    /** Creates a ReplaceableQuery */
-    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
-    /** Creates a ReplaceableSetQuery */
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Record<string, import("nostr-tools").Event>>;
-    /** 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>;
-    /** Creates a ReactionsQuery */
-    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** 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

@@ -1,68 +0,0 @@
-import { LRU } from "../helpers/lru.js";
-import * as Queries from "../queries/index.js";
-import { shareLatestValue } from "../observable/share-latest-value.js";
-export class QueryStore {
-    static Queries = Queries;
-    store;
-    constructor(store) {
-        if (!store)
-            throw new Error("EventStore required");
-        this.store = store;
-    }
-    queries = new LRU();
-    observables = new WeakMap();
-    /** Creates a cached 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);
-    }
-    /** Creates a SingleEventQuery */
-    event(id) {
-        return this.createQuery(Queries.SingleEventQuery, id);
-    }
-    /** Creates a MultipleEventsQuery */
-    events(ids) {
-        return this.createQuery(Queries.MultipleEventsQuery, ids);
-    }
-    /** Creates a ReplaceableQuery */
-    replaceable(kind, pubkey, d) {
-        return this.createQuery(Queries.ReplaceableQuery, kind, pubkey, d);
-    }
-    /** Creates a ReplaceableSetQuery */
-    replaceableSet(pointers) {
-        return this.createQuery(Queries.ReplaceableSetQuery, pointers);
-    }
-    /** Creates a TimelineQuery */
-    timeline(filters, keepOldVersions) {
-        return this.createQuery(Queries.TimelineQuery, filters, keepOldVersions);
-    }
-    /** Creates a ProfileQuery */
-    profile(pubkey) {
-        return this.createQuery(Queries.ProfileQuery, pubkey);
-    }
-    /** Creates a ReactionsQuery */
-    reactions(event) {
-        return this.createQuery(Queries.ReactionsQuery, event);
-    }
-    /** Creates a MailboxesQuery */
-    mailboxes(pubkey) {
-        return this.createQuery(Queries.MailboxesQuery, pubkey);
-    }
-    /** Creates a ThreadQuery */
-    thread(root) {
-        return this.createQuery(Queries.ThreadQuery, root);
-    }
-}
-export { Queries };