applesauce-core 0.0.0-next-20241103143210

package/dist/observable/stateful.js

@@ -0,0 +1,60 @@
+import { Observable } from "rxjs";
+/** Wraps an {@link Observable} and makes it stateful */
+export function stateful(observable, cleanup = false) {
+    let subscription = undefined;
+    let observers = [];
+    const self = new Observable((observer) => {
+        // add observer to list
+        observers.push(observer);
+        // pass any cached values
+        if (self.value)
+            observer.next(self.value);
+        if (self.error)
+            observer.error(self.error);
+        if (self.complete)
+            observer.complete();
+        // subscribe if not already
+        if (!subscription) {
+            subscription = observable.subscribe({
+                next: (v) => {
+                    self.value = v;
+                    for (const observer of observers)
+                        observer.next(v);
+                },
+                error: (err) => {
+                    self.error = err;
+                    for (const observer of observers)
+                        observer.error(err);
+                },
+                complete: () => {
+                    self.complete = true;
+                    for (const observer of observers)
+                        observer.complete();
+                },
+            });
+        }
+        return () => {
+            let i = observers.indexOf(observer);
+            if (i !== -1) {
+                // remove observer from list
+                observers.splice(i, 1);
+                if (subscription && observers.length === 0) {
+                    subscription.unsubscribe();
+                    subscription = undefined;
+                    // reset cached values
+                    if (cleanup) {
+                        delete self.value;
+                        delete self.error;
+                        delete self.complete;
+                    }
+                }
+            }
+        };
+    });
+    self._stateful = true;
+    return self;
+}
+export function isStateful(observable) {
+    // @ts-expect-error
+    return observable._stateful;
+}

package/dist/observable/throttle.d.ts

@@ -0,0 +1,3 @@
+import Observable from "zen-observable";
+/** Throttles an {@link Observable} */
+export declare function throttle<T>(source: Observable<T>, interval: number): Observable<T>;

package/dist/observable/throttle.js

@@ -0,0 +1,23 @@
+import Observable from "zen-observable";
+/** Throttles an {@link Observable} */
+export function throttle(source, interval) {
+    return new Observable((observer) => {
+        let lastEmissionTime = 0;
+        let subscription = source.subscribe({
+            next(value) {
+                const currentTime = Date.now();
+                if (currentTime - lastEmissionTime >= interval) {
+                    lastEmissionTime = currentTime;
+                    observer.next(value);
+                }
+            },
+            error(err) {
+                observer.error(err);
+            },
+            complete() {
+                observer.complete();
+            },
+        });
+        return () => subscription.unsubscribe();
+    });
+}

package/dist/promise/deferred.d.ts

@@ -0,0 +1,5 @@
+export type Deferred<T> = Promise<T> & {
+    resolve: (value?: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export declare function createDefer<T>(): Deferred<T>;

package/dist/promise/deferred.js

@@ -0,0 +1,14 @@
+export function createDefer() {
+    let _resolve;
+    let _reject;
+    const promise = new Promise((resolve, reject) => {
+        // @ts-ignore
+        _resolve = resolve;
+        _reject = reject;
+    });
+    // @ts-ignore
+    promise.resolve = _resolve;
+    // @ts-ignore
+    promise.reject = _reject;
+    return promise;
+}

package/dist/promise/index.d.ts

@@ -0,0 +1 @@
+export * from "./deferred.js";

package/dist/promise/index.js

@@ -0,0 +1 @@
+export * from "./deferred.js";

package/dist/queries/index.d.ts

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

package/dist/queries/index.js

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

package/dist/queries/mailboxes.d.ts

@@ -0,0 +1,5 @@
+import { Query } from "../query-store/index.js";
+export declare function MailboxesQuery(pubkey: string): Query<{
+    inboxes: string[];
+    outboxes: string[];
+} | undefined>;

package/dist/queries/mailboxes.js

@@ -0,0 +1,12 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+export function MailboxesQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
+            inboxes: getInboxes(event),
+            outboxes: getOutboxes(event),
+        })),
+    };
+}

package/dist/queries/profile.d.ts

@@ -0,0 +1,3 @@
+import { ProfileContent } from "../helpers/profile.js";
+import { Query } from "../query-store/index.js";
+export declare function ProfileQuery(pubkey: string): Query<ProfileContent | undefined>;

package/dist/queries/profile.js

@@ -0,0 +1,11 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { getProfileContent } from "../helpers/profile.js";
+export function ProfileQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => {
+            return events.replaceable(kinds.Metadata, pubkey).pipe(map((event) => event && getProfileContent(event)));
+        },
+    };
+}

package/dist/queries/reactions.d.ts

@@ -0,0 +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) */
+export declare function ReactionsQuery(event: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/reactions.js

@@ -0,0 +1,19 @@
+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) */
+export function ReactionsQuery(event) {
+    return {
+        key: getEventUID(event),
+        run: (events) => events.timeline(isReplaceable(event.kind)
+            ? [
+                { kinds: [kinds.Reaction], "#e": [event.id] },
+                { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
+            ]
+            : [
+                {
+                    kinds: [kinds.Reaction],
+                    "#e": [event.id],
+                },
+            ]),
+    };
+}

package/dist/queries/simple.d.ts

@@ -0,0 +1,16 @@
+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>;
+/** Creates a Query that returns a multiple events in a map */
+export declare function MultipleEventsQuery(uids: 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[]>;
+/** Creates a Query that returns a directory of events by their UID */
+export declare function ReplaceableSetQuery(pointers: {
+    kind: number;
+    pubkey: string;
+    identifier?: string;
+}[]): Query<Map<string, NostrEvent>>;

package/dist/queries/simple.js

@@ -0,0 +1,38 @@
+import stringify from "json-stringify-deterministic";
+import { getReplaceableUID } from "../helpers/event.js";
+/** Creates a Query that returns a single event or undefined */
+export function SingleEventQuery(uid) {
+    return {
+        key: uid,
+        run: (events) => events.event(uid),
+    };
+}
+/** Creates a Query that returns a multiple events in a map */
+export function MultipleEventsQuery(uids) {
+    return {
+        key: uids.join(","),
+        run: (events) => events.events(uids),
+    };
+}
+/** 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) {
+    return {
+        key: stringify(filters),
+        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
+    };
+}
+/** 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),
+    };
+}

package/dist/queries/thread.d.ts

@@ -0,0 +1,23 @@
+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>;

package/dist/queries/thread.js

@@ -0,0 +1,66 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { getNip10References } from "../helpers/threading.js";
+import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
+import { getEventUID } from "../helpers/event.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 };
+        })),
+    };
+}

package/dist/queries/zaps.d.ts

@@ -0,0 +1,4 @@
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+export declare function EventZapsQuery(id: string | EventPointer | AddressPointer): Query<NostrEvent[]>;

package/dist/queries/zaps.js

@@ -0,0 +1,16 @@
+import { kinds } from "nostr-tools";
+import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
+export function EventZapsQuery(id) {
+    return {
+        key: JSON.stringify(id),
+        run: (events) => {
+            if (isAddressPointer(id)) {
+                return events.timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }]);
+            }
+            else {
+                id = typeof id === "string" ? id : id.id;
+                return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,47 @@
+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> = {
+    key: string;
+    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<Observable<any> | BehaviorSubject<any>>;
+    /** Creates a cached query */
+    runQuery<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 */
+    event(id: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Returns a single event */
+    events(ids: string[]): Observable<Map<string, import("nostr-tools").Event>>;
+    /** Returns the latest version of a replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Returns a directory of events by their UID */
+    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 */
+    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Returns all reactions for an event (supports replaceable events) */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** Returns the parsed relay list (10002) for the pubkey */
+    mailboxes(pubkey: string): Observable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
+}
+export { Queries };

package/dist/query-store/index.js

@@ -0,0 +1,60 @@
+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) {
+        this.store = store;
+    }
+    queries = new LRU();
+    /** 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 */
+    event(id) {
+        return this.runQuery(Queries.SingleEventQuery)(id);
+    }
+    /** Returns a single event */
+    events(ids) {
+        return this.runQuery(Queries.MultipleEventsQuery)(ids);
+    }
+    /** Returns the latest version of a replaceable event */
+    replaceable(kind, pubkey, d) {
+        return this.runQuery(Queries.ReplaceableQuery)(kind, pubkey, d);
+    }
+    /** Returns a directory of events by their UID */
+    replaceableSet(pointers) {
+        return this.runQuery(Queries.ReplaceableSetQuery)(pointers);
+    }
+    /** Returns an array of events that match the filter */
+    timeline(filters) {
+        return this.runQuery(Queries.TimelineQuery)(filters);
+    }
+    /** Returns the parsed profile (0) for a pubkey */
+    profile(pubkey) {
+        return this.runQuery(Queries.ProfileQuery)(pubkey);
+    }
+    /** Returns all reactions for an event (supports replaceable events) */
+    reactions(event) {
+        return this.runQuery(Queries.ReactionsQuery)(event);
+    }
+    /** Returns the parsed relay list (10002) for the pubkey */
+    mailboxes(pubkey) {
+        return this.runQuery(Queries.MailboxesQuery)(pubkey);
+    }
+    thread(root) {
+        return this.runQuery(Queries.ThreadQuery)(root);
+    }
+}
+export { Queries };

package/dist/utils/lru.d.ts

@@ -0,0 +1,32 @@
+type Item<T> = {
+    key: string;
+    prev: Item<T> | null;
+    value: T;
+    next: Item<T> | null;
+    expiry: number;
+};
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export declare class LRU<T extends unknown> {
+    first: Item<T> | null;
+    items: Record<string, Item<T>>;
+    last: Item<T> | null;
+    max: number;
+    resetTtl: boolean;
+    size: number;
+    ttl: number;
+    constructor(max?: number, ttl?: number, resetTtl?: boolean);
+    clear(): this;
+    delete(key: string): this;
+    entries(keys?: string[]): (string | T | undefined)[][];
+    evict(bypass?: boolean): this;
+    expiresAt(key: string): number | undefined;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    keys(): string[];
+    set(key: string, value: T, bypass?: boolean, resetTtl?: boolean): this;
+    values(keys?: string[]): NonNullable<T>[];
+}
+export {};

package/dist/utils/lru.js

@@ -0,0 +1,148 @@
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export class LRU {
+    first = null;
+    items = Object.create(null);
+    last = null;
+    max;
+    resetTtl;
+    size;
+    ttl;
+    constructor(max = 0, ttl = 0, resetTtl = false) {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.max = max;
+        this.resetTtl = resetTtl;
+        this.size = 0;
+        this.ttl = ttl;
+    }
+    clear() {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.size = 0;
+        return this;
+    }
+    delete(key) {
+        if (this.has(key)) {
+            const item = this.items[key];
+            delete this.items[key];
+            this.size--;
+            if (item.prev !== null) {
+                item.prev.next = item.next;
+            }
+            if (item.next !== null) {
+                item.next.prev = item.prev;
+            }
+            if (this.first === item) {
+                this.first = item.next;
+            }
+            if (this.last === item) {
+                this.last = item.prev;
+            }
+        }
+        return this;
+    }
+    entries(keys = this.keys()) {
+        return keys.map((key) => [key, this.get(key)]);
+    }
+    evict(bypass = false) {
+        if (bypass || this.size > 0) {
+            const item = this.first;
+            delete this.items[item.key];
+            if (--this.size === 0) {
+                this.first = null;
+                this.last = null;
+            }
+            else {
+                this.first = item.next;
+                this.first.prev = null;
+            }
+        }
+        return this;
+    }
+    expiresAt(key) {
+        let result;
+        if (this.has(key)) {
+            result = this.items[key].expiry;
+        }
+        return result;
+    }
+    get(key) {
+        let result;
+        if (this.has(key)) {
+            const item = this.items[key];
+            if (this.ttl > 0 && item.expiry <= Date.now()) {
+                this.delete(key);
+            }
+            else {
+                result = item.value;
+                this.set(key, result, true);
+            }
+        }
+        return result;
+    }
+    has(key) {
+        return key in this.items;
+    }
+    keys() {
+        const result = [];
+        let x = this.first;
+        while (x !== null) {
+            result.push(x.key);
+            x = x.next;
+        }
+        return result;
+    }
+    set(key, value, bypass = false, resetTtl = this.resetTtl) {
+        let item;
+        if (bypass || this.has(key)) {
+            item = this.items[key];
+            item.value = value;
+            if (bypass === false && resetTtl) {
+                item.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+            }
+            if (this.last !== item) {
+                const last = this.last, next = item.next, prev = item.prev;
+                if (this.first === item) {
+                    this.first = item.next;
+                }
+                item.next = null;
+                item.prev = this.last;
+                last.next = item;
+                if (prev !== null) {
+                    prev.next = next;
+                }
+                if (next !== null) {
+                    next.prev = prev;
+                }
+            }
+        }
+        else {
+            if (this.max > 0 && this.size === this.max) {
+                this.evict(true);
+            }
+            item = this.items[key] = {
+                expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+                key: key,
+                prev: this.last,
+                next: null,
+                value,
+            };
+            if (++this.size === 1) {
+                this.first = item;
+            }
+            else {
+                this.last.next = item;
+            }
+        }
+        this.last = item;
+        return this;
+    }
+    values(keys = this.keys()) {
+        return keys.map((key) => this.get(key));
+    }
+}