applesauce-core 0.2.0 → 0.4.0

package/dist/helpers/relays.d.ts

@@ -1,4 +1,10 @@
 import { NostrEvent } from "nostr-tools";
+export declare const SeenRelaysSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [SeenRelaysSymbol]?: Set<string>;
+    }
+}
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
 export declare function getSeenRelays(event: NostrEvent): Set<string> | undefined;
 export declare function validateRelayURL(relay: string | URL): URL;

package/dist/helpers/relays.js

@@ -1,12 +1,13 @@
-import { FromRelays } from "./symbols.js";
+export const SeenRelaysSymbol = Symbol.for("seen-relays");
+// Seen relays
 export function addSeenRelay(event, relay) {
-    if (!event[FromRelays])
-        event[FromRelays] = new Set();
-    event[FromRelays].add(relay);
-    return event[FromRelays];
+    if (!event[SeenRelaysSymbol])
+        event[SeenRelaysSymbol] = new Set();
+    event[SeenRelaysSymbol].add(relay);
+    return event[SeenRelaysSymbol];
 }
 export function getSeenRelays(event) {
-    return event[FromRelays];
+    return event[SeenRelaysSymbol];
 }
 // Relay URLs
 export function validateRelayURL(relay) {

package/dist/helpers/threading.d.ts

@@ -0,0 +1,55 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+export type ThreadReferences = {
+    root?: {
+        e: EventPointer;
+        a: undefined;
+    } | {
+        e: undefined;
+        a: AddressPointer;
+    } | {
+        e: EventPointer;
+        a: AddressPointer;
+    };
+    reply?: {
+        e: EventPointer;
+        a: undefined;
+    } | {
+        e: undefined;
+        a: AddressPointer;
+    } | {
+        e: EventPointer;
+        a: AddressPointer;
+    };
+};
+export declare const Nip10ThreadRefsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [Nip10ThreadRefsSymbol]?: ThreadReferences;
+    }
+}
+/** Parses NIP-10 tags and handles legacy behavior */
+export declare function interpretThreadTags(event: NostrEvent): {
+    root?: {
+        e: string[];
+        a: undefined;
+    } | {
+        e: undefined;
+        a: string[];
+    } | {
+        e: string[];
+        a: string[];
+    } | undefined;
+    reply?: {
+        e: string[];
+        a: undefined;
+    } | {
+        e: undefined;
+        a: string[];
+    } | {
+        e: string[];
+        a: string[];
+    } | undefined;
+};
+/** Returns the parsed NIP-10 tags for an event */
+export declare function getNip10References(event: NostrEvent): ThreadReferences;

package/dist/helpers/threading.js

@@ -0,0 +1,61 @@
+import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
+/** Parses NIP-10 tags and handles legacy behavior */
+export function interpretThreadTags(event) {
+    const eTags = event.tags.filter((t) => t[0] === "e" && t[1]);
+    const aTags = event.tags.filter((t) => t[0] === "a" && t[1]);
+    // find the root and reply tags.
+    let rootETag = eTags.find((t) => t[3] === "root");
+    let replyETag = eTags.find((t) => t[3] === "reply");
+    let rootATag = aTags.find((t) => t[3] === "root");
+    let replyATag = aTags.find((t) => t[3] === "reply");
+    if (!rootETag || !replyETag) {
+        // a direct reply does not need a "reply" reference
+        // https://github.com/nostr-protocol/nips/blob/master/10.md
+        // this is not necessarily to spec. but if there is only one id (root or reply) then assign it to both
+        // this handles the cases where a client only set a "reply" tag and no root
+        rootETag = replyETag = rootETag || replyETag;
+    }
+    if (!rootATag || !replyATag) {
+        rootATag = replyATag = rootATag || replyATag;
+    }
+    if (!rootETag && !replyETag) {
+        // legacy behavior
+        // https://github.com/nostr-protocol/nips/blob/master/10.md#positional-e-tags-deprecated
+        const legacyETags = eTags.filter((t) => {
+            // ignore it if there is a marker
+            if (t[3])
+                return false;
+            return true;
+        });
+        if (legacyETags.length >= 1) {
+            // first tag is the root
+            rootETag = legacyETags[0];
+            // last tag is reply
+            replyETag = legacyETags[legacyETags.length - 1] ?? rootETag;
+        }
+    }
+    return {
+        root: rootETag || rootATag ? { e: rootETag, a: rootATag } : undefined,
+        reply: replyETag || replyATag ? { e: replyETag, a: replyATag } : undefined,
+    };
+}
+/** Returns the parsed NIP-10 tags for an event */
+export function getNip10References(event) {
+    let refs = event[Nip10ThreadRefsSymbol];
+    if (!refs) {
+        const e = event;
+        const tags = interpretThreadTags(e);
+        refs = event[Nip10ThreadRefsSymbol] = {
+            root: tags.root && {
+                e: tags.root.e && getEventPointerFromTag(tags.root.e),
+                a: tags.root.a && getAddressPointerFromTag(tags.root.a),
+            },
+            reply: tags.reply && {
+                e: tags.reply.e && getEventPointerFromTag(tags.reply.e),
+                a: tags.reply.a && getAddressPointerFromTag(tags.reply.a),
+            },
+        };
+    }
+    return refs;
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./event-store/index.js";
 export * from "./query-store/index.js";
 export * as helpers from "./helpers/index.js";
+export * as Queries from "./queries/index.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./event-store/index.js";
 export * from "./query-store/index.js";
 export * as helpers from "./helpers/index.js";
+export * as Queries from "./queries/index.js";

package/dist/observable/stateful.d.ts

@@ -5,6 +5,6 @@ export type StatefulObservable<T> = Observable<T> & {
     error?: Error;
     complete?: boolean;
 };
-/** Wraps an observable and makes it stateful */
+/** Wraps an {@link Observable} and makes it stateful */
 export declare function stateful<T extends unknown>(observable: Observable<T>, cleanup?: boolean): StatefulObservable<T>;
 export declare function isStateful<T extends unknown>(observable: Observable<T> | StatefulObservable<T>): observable is StatefulObservable<T>;

package/dist/observable/stateful.js

@@ -1,5 +1,5 @@
 import Observable from "zen-observable";
-/** Wraps an observable and makes it stateful */
+/** Wraps an {@link Observable} and makes it stateful */
 export function stateful(observable, cleanup = false) {
     let subscription = undefined;
     let observers = [];

package/dist/observable/throttle.d.ts

@@ -1,2 +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

@@ -1,4 +1,5 @@
 import Observable from "zen-observable";
+/** Throttles an {@link Observable} */
 export function throttle(source, interval) {
     return new Observable((observer) => {
         let lastEmissionTime = 0;

package/dist/promise/index.d.ts

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

package/dist/promise/index.js

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

package/dist/queries/channel.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+import { ChannelMetadataContent } from "../helpers/channel.js";
+/** Creates a query that returns the latest parsed metadata */
+export declare function ChannelMetadataQuery(channel: NostrEvent): Query<ChannelMetadataContent | undefined>;
+/** Creates a query that returns a map of hidden messages Map<id, reason> */
+export declare function ChannelHiddenQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** Creates a query that returns a map of muted users Map<pubkey, reason> */
+export declare function ChannelMutedQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** Creates a query that returns all messages in a channel */
+export declare function ChannelMessagesQuery(channel: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/channel.js

@@ -0,0 +1,72 @@
+import { kinds } from "nostr-tools";
+import { getChannelMetadataContent } from "../helpers/channel.js";
+import { safeParse } from "../helpers/json.js";
+/** Creates a query that returns the latest parsed metadata */
+export function ChannelMetadataQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const filters = [
+                { ids: [channel.id] },
+                { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
+            ];
+            let latest = channel;
+            return events.stream(filters).map((event) => {
+                try {
+                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                        latest = event;
+                    }
+                    return getChannelMetadataContent(latest);
+                }
+                catch (error) {
+                    return undefined;
+                }
+            });
+        },
+    };
+}
+/** Creates a query that returns a map of hidden messages Map<id, reason> */
+export function ChannelHiddenQuery(channel, authors = []) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const hidden = new Map();
+            return events
+                .stream([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "e" && tag[1])
+                        hidden.set(tag[1], reason ?? "");
+                }
+                return hidden;
+            });
+        },
+    };
+}
+/** Creates a query that returns a map of muted users Map<pubkey, reason> */
+export function ChannelMutedQuery(channel, authors = []) {
+    return {
+        key: channel.id + authors.join(","),
+        run: (events) => {
+            const muted = new Map();
+            return events
+                .stream([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "p" && tag[1])
+                        muted.set(tag[1], reason ?? "");
+                }
+                return muted;
+            });
+        },
+    };
+}
+/** Creates a query that returns all messages in a channel */
+export function ChannelMessagesQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]),
+    };
+}

package/dist/queries/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./simple.js";
+export * from "./profile.js";
+export * from "./mailboxes.js";
+export * from "./reactions.js";
+export * from "./channel.js";
+export * from "./mute.js";
+export * from "./thread.js";

package/dist/queries/index.js

@@ -0,0 +1,7 @@
+export * from "./simple.js";
+export * from "./profile.js";
+export * from "./mailboxes.js";
+export * from "./reactions.js";
+export * from "./channel.js";
+export * from "./mute.js";
+export * from "./thread.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: Set<string>;
+    outboxes: Set<string>;
+} | undefined>;

package/dist/queries/mailboxes.js

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

package/dist/queries/mute.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "../query-store/index.js";
+export declare function UserMuteQuery(pubkey: string): Query<{
+    words: Set<string>;
+    pubkeys: Set<string>;
+    threads: Set<string>;
+    hashtags: Set<string>;
+} | undefined>;

package/dist/queries/mute.js

@@ -0,0 +1,16 @@
+import { kinds } from "nostr-tools";
+import { getMutedHashtags, getMutedPubkeys, getMutedThreads, getMutedWords } from "../helpers/mute.js";
+export function UserMuteQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).map((event) => {
+            if (!event)
+                return;
+            const pubkeys = getMutedPubkeys(event);
+            const threads = getMutedThreads(event);
+            const hashtags = getMutedHashtags(event);
+            const words = getMutedWords(event);
+            return { pubkeys, threads, hashtags, words };
+        }),
+    };
+}

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,10 @@
+import { kinds } from "nostr-tools";
+import { getProfileContent } from "../helpers/profile.js";
+export function ProfileQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => {
+            return events.replaceable(kinds.Metadata, pubkey).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,5 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+export declare function SingleEventQuery(uid: string): Query<NostrEvent | undefined>;
+export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
+export declare function TimelineQuery(filters: Filter | Filter[]): Query<NostrEvent[]>;

package/dist/queries/simple.js

@@ -0,0 +1,20 @@
+import stringify from "json-stringify-deterministic";
+import { getReplaceableUID } from "../helpers/event.js";
+export function SingleEventQuery(uid) {
+    return {
+        key: uid,
+        run: (events) => events.event(uid),
+    };
+}
+export function ReplaceableQuery(kind, pubkey, d) {
+    return {
+        key: getReplaceableUID(kind, pubkey, d),
+        run: (events) => events.replaceable(kind, pubkey, d),
+    };
+}
+export function TimelineQuery(filters) {
+    return {
+        key: stringify(filters),
+        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
+    };
+}

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,65 @@
+import { kinds } from "nostr-tools";
+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]).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/query-store/index.d.ts

@@ -1,26 +1,46 @@
 import Observable from "zen-observable";
 import { Filter, NostrEvent } from "nostr-tools";
 import { EventStore } from "../event-store/event-store.js";
-import { ProfileContent } from "../helpers/profile.js";
 import { LRU } from "../utils/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);
-    singleEvents: LRU<Observable<import("nostr-tools").Event | undefined>>;
-    getEvent(id: string): Observable<import("nostr-tools").Event | undefined>;
-    getReplaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
-    timelines: LRU<Observable<import("nostr-tools").Event[]>>;
-    getTimeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
-    profiles: LRU<Observable<ProfileContent | undefined>>;
-    getProfile(pubkey: string): Observable<ProfileContent | undefined>;
-    reactions: LRU<Observable<import("nostr-tools").Event[]>>;
-    getReactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    mailboxes: LRU<Observable<{
-        inboxes: Set<string>;
-        outboxes: Set<string>;
-    } | undefined>>;
-    getMailboxes(pubkey: string): Observable<{
+    queries: LRU<Observable<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 the latest version of a replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
+    /** 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: Set<string>;
         outboxes: Set<string>;
     } | undefined>;
+    /** Returns the parsed mute list for the pubkey */
+    mute(pubkey: string): Observable<{
+        words: Set<string>;
+        pubkeys: Set<string>;
+        threads: Set<string>;
+        hashtags: Set<string>;
+    } | undefined>;
+    thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
 }
+export { Queries };