applesauce-core 0.3.0 → 0.4.0

package/dist/helpers/event.d.ts

@@ -12,7 +12,15 @@ declare module "nostr-tools" {
  * or parameterized replaceable ( 30000 <= n < 40000 )
  */
 export declare function isReplaceable(kind: number): boolean;
-/** returns the events Unique ID */
+/**
+ * Returns the events Unique ID
+ * For normal or ephemeral events this is ( event.id )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ */
 export declare function getEventUID(event: NostrEvent): string;
 export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
+/** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
+/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+export declare function getTagValue(event: NostrEvent, name: string): string | undefined;

package/dist/helpers/event.js

@@ -9,31 +9,43 @@ export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export function isReplaceable(kind) {
     return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
 }
-/** returns the events Unique ID */
+/**
+ * Returns the events Unique ID
+ * For normal or ephemeral events this is ( event.id )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ */
 export function getEventUID(event) {
-    if (!event[EventUIDSymbol]) {
+    let id = event[EventUIDSymbol];
+    if (!id) {
         if (isReplaceable(event.kind)) {
             const d = event.tags.find((t) => t[0] === "d")?.[1];
-            event[EventUIDSymbol] = getReplaceableUID(event.kind, event.pubkey, d);
+            id = getReplaceableUID(event.kind, event.pubkey, d);
         }
         else {
-            event[EventUIDSymbol] = event.id;
+            id = event.id;
         }
     }
-    return event[EventUIDSymbol];
+    return id;
 }
 export function getReplaceableUID(kind, pubkey, d) {
     return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
 }
+/** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
-    if (!event[EventIndexableTagsSymbol]) {
+    let indexable = event[EventIndexableTagsSymbol];
+    if (!indexable) {
         const tags = new Set();
         for (const tag of event.tags) {
             if (tag[0] && INDEXABLE_TAGS.has(tag[0]) && tag[1]) {
                 tags.add(tag[0] + ":" + tag[1]);
             }
         }
-        event[EventIndexableTagsSymbol] = tags;
+        indexable = event[EventIndexableTagsSymbol] = tags;
     }
-    return event[EventIndexableTagsSymbol];
+    return indexable;
+}
+/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+export function getTagValue(event, name) {
+    return event.tags.find((t) => t[0] === name)?.[1];
 }

package/dist/helpers/index.d.ts

@@ -3,3 +3,5 @@ export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
 export * from "./mailboxes.js";
+export * from "./threading.js";
+export * from "./pointers.js";

package/dist/helpers/index.js

@@ -3,3 +3,5 @@ export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
 export * from "./mailboxes.js";
+export * from "./threading.js";
+export * from "./pointers.js";

package/dist/helpers/pointers.d.ts

@@ -0,0 +1,22 @@
+import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
+    identifier?: string;
+};
+export declare function parseCoordinate(a: string): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: false): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: false): AddressPointerWithoutD;
+export declare function parseCoordinate(a: string, requireD: true, silent: false): AddressPointer;
+export declare function parseCoordinate(a: string, requireD: true, silent: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
+export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nsec1${string}` | `npub1${string}` | `note1${string}` | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nrelay1${string}`;
+export declare function getEventPointerFromTag(tag: string[]): EventPointer;
+export declare function getAddressPointerFromTag(tag: string[]): AddressPointer;
+export declare function getProfilePointerFromTag(tag: string[]): ProfilePointer;
+export declare function getPointerFromTag(tag: string[]): DecodeResult | null;
+export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
+export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
+export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
+export declare function getATagFromAddressPointer(pointer: AddressPointer): ["a", ...string[]];
+export declare function getETagFromEventPointer(pointer: EventPointer): ["e", ...string[]];

package/dist/helpers/pointers.js

@@ -0,0 +1,127 @@
+import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nrelayEncode, nsecEncode, } from "nostr-tools/nip19";
+import { getPublicKey } from "nostr-tools";
+import { safeRelayUrls } from "./relays.js";
+export function parseCoordinate(a, requireD = false, silent = true) {
+    const parts = a.split(":");
+    const kind = parts[0] && parseInt(parts[0]);
+    const pubkey = parts[1];
+    const d = parts[2];
+    if (!kind) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing kind");
+    }
+    if (!pubkey) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing pubkey");
+    }
+    if (requireD && d === undefined) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing identifier");
+    }
+    return {
+        kind,
+        pubkey,
+        identifier: d,
+    };
+}
+export function getPubkeyFromDecodeResult(result) {
+    if (!result)
+        return;
+    switch (result.type) {
+        case "naddr":
+        case "nprofile":
+            return result.data.pubkey;
+        case "npub":
+            return result.data;
+        case "nsec":
+            return getPublicKey(result.data);
+        default:
+            return undefined;
+    }
+}
+export function encodeDecodeResult(result) {
+    switch (result.type) {
+        case "naddr":
+            return naddrEncode(result.data);
+        case "nprofile":
+            return nprofileEncode(result.data);
+        case "nevent":
+            return neventEncode(result.data);
+        case "nrelay":
+            return nrelayEncode(result.data);
+        case "nsec":
+            return nsecEncode(result.data);
+        case "npub":
+            return npubEncode(result.data);
+        case "note":
+            return noteEncode(result.data);
+    }
+    return "";
+}
+export function getEventPointerFromTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+export function getAddressPointerFromTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing coordinate in tag");
+    const pointer = parseCoordinate(tag[1], true, false);
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+export function getProfilePointerFromTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing pubkey in tag");
+    const pointer = { pubkey: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+export function getPointerFromTag(tag) {
+    try {
+        switch (tag[0]) {
+            case "e":
+                return { type: "nevent", data: getEventPointerFromTag(tag) };
+            case "a":
+                return {
+                    type: "naddr",
+                    data: getAddressPointerFromTag(tag),
+                };
+            case "p":
+                return { type: "nprofile", data: getProfilePointerFromTag(tag) };
+        }
+    }
+    catch (error) { }
+    return null;
+}
+export function isAddressPointer(pointer) {
+    return (typeof pointer !== "string" &&
+        Object.hasOwn(pointer, "identifier") &&
+        Object.hasOwn(pointer, "pubkey") &&
+        Object.hasOwn(pointer, "kind"));
+}
+export function isEventPointer(pointer) {
+    return typeof pointer !== "string" && Object.hasOwn(pointer, "id");
+}
+export function getCoordinateFromAddressPointer(pointer) {
+    return `${pointer.kind}:${pointer.pubkey}:${pointer.identifier}`;
+}
+export function getATagFromAddressPointer(pointer) {
+    const relay = pointer.relays?.[0];
+    const coordinate = getCoordinateFromAddressPointer(pointer);
+    return relay ? ["a", coordinate, relay] : ["a", coordinate];
+}
+export function getETagFromEventPointer(pointer) {
+    return pointer.relays?.length ? ["e", pointer.id, pointer.relays[0]] : ["e", pointer.id];
+}

package/dist/helpers/profile.d.ts

@@ -19,6 +19,7 @@ export type ProfileContent = {
     lud06?: string;
     nip05?: string;
 };
+/** Returns the parsed profile content for a kind 0 event */
 export declare function getProfileContent(event: NostrEvent): ProfileContent;
 export declare function getProfileContent(event: NostrEvent, quite: false): ProfileContent;
 export declare function getProfileContent(event: NostrEvent, quite: true): ProfileContent | Error;

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/{query-store/queries → queries}/channel.d.ts

@@ -1,6 +1,6 @@
 import { NostrEvent } from "nostr-tools";
-import { Query } from "../index.js";
-import { ChannelMetadataContent } from "../../helpers/channel.js";
+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> */

package/dist/{query-store/queries → queries}/channel.js

@@ -1,6 +1,6 @@
 import { kinds } from "nostr-tools";
-import { getChannelMetadataContent } from "../../helpers/channel.js";
-import { safeParse } from "../../helpers/json.js";
+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 {

package/dist/{query-store/queries → queries}/index.d.ts

@@ -4,3 +4,4 @@ export * from "./mailboxes.js";
 export * from "./reactions.js";
 export * from "./channel.js";
 export * from "./mute.js";
+export * from "./thread.js";

package/dist/{query-store/queries → queries}/index.js

@@ -4,3 +4,4 @@ export * from "./mailboxes.js";
 export * from "./reactions.js";
 export * from "./channel.js";
 export * from "./mute.js";
+export * from "./thread.js";

package/dist/{query-store/queries → queries}/mailboxes.d.ts

@@ -1,4 +1,4 @@
-import { Query } from "../index.js";
+import { Query } from "../query-store/index.js";
 export declare function MailboxesQuery(pubkey: string): Query<{
     inboxes: Set<string>;
     outboxes: Set<string>;

package/dist/{query-store/queries → queries}/mailboxes.js

@@ -1,5 +1,5 @@
 import { kinds } from "nostr-tools";
-import { getInboxes, getOutboxes } from "../../helpers/mailboxes.js";
+import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 export function MailboxesQuery(pubkey) {
     return {
         key: pubkey,

package/dist/{query-store/queries → queries}/mute.d.ts

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

package/dist/{query-store/queries → queries}/mute.js

@@ -1,5 +1,5 @@
 import { kinds } from "nostr-tools";
-import { getMutedHashtags, getMutedPubkeys, getMutedThreads, getMutedWords } from "../../helpers/mute.js";
+import { getMutedHashtags, getMutedPubkeys, getMutedThreads, getMutedWords } from "../helpers/mute.js";
 export function UserMuteQuery(pubkey) {
     return {
         key: pubkey,

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/{query-store/queries → queries}/profile.js

@@ -1,5 +1,5 @@
 import { kinds } from "nostr-tools";
-import { getProfileContent } from "../../helpers/profile.js";
+import { getProfileContent } from "../helpers/profile.js";
 export function ProfileQuery(pubkey) {
     return {
         key: pubkey,

package/dist/{query-store/queries → queries}/reactions.d.ts

@@ -1,4 +1,4 @@
 import { NostrEvent } from "nostr-tools";
-import { Query } from "../index.js";
+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/{query-store/queries → queries}/reactions.js

@@ -1,5 +1,5 @@
 import { kinds } from "nostr-tools";
-import { getEventUID, isReplaceable } from "../../helpers/event.js";
+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 {

package/dist/{query-store/queries → queries}/simple.d.ts

@@ -1,5 +1,5 @@
 import { Filter, NostrEvent } from "nostr-tools";
-import { Query } from "../index.js";
+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/{query-store/queries → queries}/simple.js

@@ -1,5 +1,5 @@
 import stringify from "json-stringify-deterministic";
-import { getReplaceableUID } from "../../helpers/event.js";
+import { getReplaceableUID } from "../helpers/event.js";
 export function SingleEventQuery(uid) {
     return {
         key: uid,

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

@@ -2,7 +2,8 @@ import Observable from "zen-observable";
 import { Filter, NostrEvent } from "nostr-tools";
 import { EventStore } from "../event-store/event-store.js";
 import { LRU } from "../utils/lru.js";
-import * as Queries from "./queries/index.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>;
@@ -40,5 +41,6 @@ export declare class QueryStore {
         threads: Set<string>;
         hashtags: Set<string>;
     } | undefined>;
+    thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
 }
 export { Queries };

package/dist/query-store/index.js

@@ -1,6 +1,6 @@
 import { stateful } from "../observable/stateful.js";
 import { LRU } from "../utils/lru.js";
-import * as Queries from "./queries/index.js";
+import * as Queries from "../queries/index.js";
 export class QueryStore {
     static Queries = Queries;
     store;
@@ -49,5 +49,8 @@ export class QueryStore {
     mute(pubkey) {
         return this.runQuery(Queries.UserMuteQuery)(pubkey);
     }
+    thread(root) {
+        return this.runQuery(Queries.ThreadQuery)(root);
+    }
 }
 export { Queries };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -33,6 +33,10 @@
     "./event-store": {
       "import": "./dist/event-store/index.js",
       "types": "./dist/event-store/index.d.ts"
+    },
+    "./queries": {
+      "import": "./dist/queries/index.js",
+      "types": "./dist/queries/index.d.ts"
     }
   },
   "dependencies": {

package/dist/query-store/queries/profile.d.ts

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