applesauce-core 0.0.0-next-20241113103021 → 0.0.0-next-20241114194041

package/dist/helpers/channel.d.ts

@@ -0,0 +1,15 @@
+import { nip19, NostrEvent } from "nostr-tools";
+import { ChannelMetadata } from "nostr-tools/nip28";
+export declare const ChannelMetadataSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ChannelMetadataSymbol]?: ChannelMetadataContent;
+    }
+}
+export type ChannelMetadataContent = ChannelMetadata & {
+    relays?: string[];
+};
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+/** gets the EventPointer for a channel message or metadata event */
+export declare function getChannelPointer(event: NostrEvent): nip19.EventPointer | undefined;

package/dist/helpers/channel.js

@@ -0,0 +1,27 @@
+export const ChannelMetadataSymbol = Symbol.for("channel-metadata");
+function parseChannelMetadataContent(channel) {
+    const metadata = JSON.parse(channel.content);
+    if (metadata.name === undefined)
+        throw new Error("Missing name");
+    if (metadata.about === undefined)
+        throw new Error("Missing about");
+    if (metadata.picture === undefined)
+        throw new Error("Missing picture");
+    if (metadata.relays && !Array.isArray(metadata.relays))
+        throw new Error("Invalid relays");
+    return metadata;
+}
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export function getChannelMetadataContent(channel) {
+    let metadata = channel[ChannelMetadataSymbol];
+    if (!metadata)
+        metadata = channel[ChannelMetadataSymbol] = parseChannelMetadataContent(channel);
+    return metadata;
+}
+/** gets the EventPointer for a channel message or metadata event */
+export function getChannelPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e" && t[1]);
+    if (!tag)
+        return undefined;
+    return tag[2] ? { id: tag[1], relays: [tag[2]] } : { id: tag[1] };
+}

package/dist/helpers/mute.d.ts

@@ -0,0 +1,21 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MutePubkeysSymbol: unique symbol;
+export declare const MuteThreadsSymbol: unique symbol;
+export declare const MuteHashtagsSymbol: unique symbol;
+export declare const MuteWordsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MutePubkeysSymbol]?: Set<string>;
+        [MuteThreadsSymbol]?: Set<string>;
+        [MuteHashtagsSymbol]?: Set<string>;
+        [MuteWordsSymbol]?: Set<string>;
+    }
+}
+/** Returns a set of muted pubkeys */
+export declare function getMutedPubkeys(mute: NostrEvent): Set<string>;
+/** Returns a set of muted threads */
+export declare function getMutedThreads(mute: NostrEvent): Set<string>;
+/** Returns a set of muted words ( lowercase ) */
+export declare function getMutedWords(mute: NostrEvent): Set<string>;
+/** Returns a set of muted hashtags ( lowercase ) */
+export declare function getMutedHashtags(mute: NostrEvent): Set<string>;

package/dist/helpers/mute.js

@@ -0,0 +1,52 @@
+export const MutePubkeysSymbol = Symbol.for("mute-pubkeys");
+export const MuteThreadsSymbol = Symbol.for("mute-threads");
+export const MuteHashtagsSymbol = Symbol.for("mute-hashtags");
+export const MuteWordsSymbol = Symbol.for("mute-words");
+/** Returns a set of muted pubkeys */
+export function getMutedPubkeys(mute) {
+    let pubkeys = mute[MutePubkeysSymbol];
+    if (!pubkeys) {
+        pubkeys = mute[MutePubkeysSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "p" && tag[1])
+                pubkeys.add(tag[1]);
+        }
+    }
+    return pubkeys;
+}
+/** Returns a set of muted threads */
+export function getMutedThreads(mute) {
+    let threads = mute[MuteThreadsSymbol];
+    if (!threads) {
+        threads = mute[MuteThreadsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "e" && tag[1])
+                threads.add(tag[1]);
+        }
+    }
+    return threads;
+}
+/** Returns a set of muted words ( lowercase ) */
+export function getMutedWords(mute) {
+    let words = mute[MuteWordsSymbol];
+    if (!words) {
+        words = mute[MuteWordsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "word" && tag[1])
+                words.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return words;
+}
+/** Returns a set of muted hashtags ( lowercase ) */
+export function getMutedHashtags(mute) {
+    let hashtags = mute[MuteHashtagsSymbol];
+    if (!hashtags) {
+        hashtags = mute[MuteHashtagsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "t" && tag[1])
+                hashtags.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return hashtags;
+}

package/dist/helpers/symbols.d.ts

@@ -0,0 +1,6 @@
+export declare const ProfileContent: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ProfileContent]?: TProfileContent | Error;
+    }
+}

package/dist/helpers/symbols.js

@@ -0,0 +1,2 @@
+// profile
+export const ProfileContent = Symbol.for("profile-content");

package/dist/helpers/user-status.d.ts

@@ -0,0 +1,22 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export declare const UserStatusPointerSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [UserStatusPointerSymbol]?: UserStatusPointer | null;
+    }
+}
+export type UserStatusPointer = {
+    type: "nevent";
+    data: EventPointer;
+} | {
+    type: "nprofile";
+    data: ProfilePointer;
+} | {
+    type: "naddr";
+    data: AddressPointer;
+} | {
+    type: "url";
+    data: string;
+};
+export declare function getUserStatusPointer(status: NostrEvent): UserStatusPointer | null;

package/dist/helpers/user-status.js

@@ -0,0 +1,24 @@
+import { getAddressPointerFromTag, getEventPointerFromTag, getProfilePointerFromTag } from "./pointers.js";
+export const UserStatusPointerSymbol = Symbol.for("user-status-pointer");
+function getStatusPointer(status) {
+    const pTag = status.tags.find((t) => t[0] === "p" && t[1]);
+    if (pTag)
+        return { type: "nprofile", data: getProfilePointerFromTag(pTag) };
+    const eTag = status.tags.find((t) => t[0] === "e" && t[1]);
+    if (eTag)
+        return { type: "nevent", data: getEventPointerFromTag(eTag) };
+    const aTag = status.tags.find((t) => t[0] === "a" && t[1]);
+    if (aTag)
+        return { type: "naddr", data: getAddressPointerFromTag(aTag) };
+    const rTag = status.tags.find((t) => t[0] === "r" && t[1]);
+    if (rTag)
+        return { type: "url", data: rTag[1] };
+    return null;
+}
+export function getUserStatusPointer(status) {
+    let pointer = status[UserStatusPointerSymbol];
+    if (pointer === undefined) {
+        pointer = status[UserStatusPointerSymbol] = getStatusPointer(status);
+    }
+    return pointer;
+}

package/dist/observable/stateful.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from "rxjs";
+import Observable from "zen-observable";
 export type StatefulObservable<T> = Observable<T> & {
     _stateful?: true;
     value?: T;

package/dist/observable/stateful.js

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

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

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { UserStatusPointer } from "../helpers/user-status.js";
+import { Query } from "../query-store/index.js";
+export type UserStatus = UserStatusPointer & {
+    event: NostrEvent;
+    content: string;
+};
+/** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
+export declare function UserStatusQuery(pubkey: string, type?: string): Query<UserStatus | undefined | null>;
+/** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
+export declare function UserStatusesQuery(pubkey: string): Query<Record<string, UserStatus>>;

package/dist/queries/user-status.js

@@ -0,0 +1,35 @@
+import { kinds } from "nostr-tools";
+import { getUserStatusPointer } from "../helpers/user-status.js";
+import { getTagValue } from "../helpers/event.js";
+/** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
+export function UserStatusQuery(pubkey, type = "general") {
+    return {
+        key: pubkey,
+        run: (events) => events.replaceable(kinds.UserStatuses, pubkey, type).map((event) => {
+            if (!event)
+                return undefined;
+            const pointer = getUserStatusPointer(event);
+            if (!pointer)
+                return null;
+            return {
+                ...pointer,
+                event,
+                content: event.content,
+            };
+        }),
+    };
+}
+/** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
+export function UserStatusesQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).map((events) => {
+            return events.reduce((dir, event) => {
+                const d = getTagValue(event, "d");
+                if (!d)
+                    return dir;
+                return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
+            }, {});
+        }),
+    };
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/query-store/queries/TimelineQuery.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../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/query-store/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/query-store/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/query-store/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/query-store/queries/mailboxes.d.ts

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

package/dist/query-store/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/query-store/queries/mute.d.ts

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

package/dist/query-store/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/query-store/queries/profile.d.ts

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

package/dist/query-store/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/query-store/queries/reactions.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../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/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/query-store/queries/simple.d.ts

@@ -0,0 +1,5 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Query } from "../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/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/query-store/queries/thread.d.ts

@@ -0,0 +1,20 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { Query } from "../index.js";
+export type ThreadItem = {
+    /** underlying nostr event */
+    event: NostrEvent;
+    /** 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<{
+    root?: ThreadItem;
+    all: ThreadItem[];
+}>;

package/dist/query-store/queries/thread.js

@@ -0,0 +1,60 @@
+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: `${root}-${kinds.join(",")}`,
+        run: (events) => events.stream([rootFilter, replyFilter]).map((event) => {
+            const refs = getNip10References(event);
+            const replies = parentReferences.get(getEventUID(event)) || new Set();
+            const item = { event, replies };
+            // add item to parent
+            if (refs.reply?.e || refs.reply?.a) {
+                let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
+                const parent = items.get(uid);
+                if (parent) {
+                    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: Array.from(items.values()) };
+        }),
+    };
+}

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

@@ -0,0 +1,3 @@
+import { Filter } from "nostr-tools";
+import { EventStore } from "../../event-store/event-store.js";
+export declare function TimelineQuery(store: EventStore): (filters: Filter | Filter[]) => import("zen-observable")<import("nostr-tools").Event[]>;

package/dist/query-store/queries/timeline.js

@@ -0,0 +1,3 @@
+export function TimelineQuery(store) {
+    return (filters) => store.timeline(Array.isArray(filters) ? filters : [filters]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20241113103021",
+  "version": "0.0.0-next-20241114194041",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -64,7 +64,8 @@
     "@types/debug": "^4.1.12",
     "@types/jest": "^29.5.13",
     "jest": "^29.7.0",
-    "jest-extended": "^4.0.2"
+    "jest-extended": "^4.0.2",
+    "typescript": "^5.6.3"
   },
   "jest": {
     "roots": [
@@ -74,6 +75,10 @@
       "jest-extended/all"
     ]
   },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
   "scripts": {
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",

package/dist/observable/share-behavior.d.ts

@@ -1,2 +0,0 @@
-import { BehaviorSubject, Observable, UnaryFunction } from "rxjs";
-export declare function shareBehavior<T>(): UnaryFunction<Observable<T>, BehaviorSubject<T | undefined>>;

package/dist/observable/share-behavior.js

@@ -1,7 +0,0 @@
-import { BehaviorSubject, share } from "rxjs";
-export function shareBehavior() {
-    return share({
-        connector: () => new BehaviorSubject(undefined),
-        resetOnRefCountZero: false,
-    });
-}