applesauce-common 0.0.0-next-20251203172109

package/dist/models/channels.js

@@ -0,0 +1,61 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { safeParse } from "applesauce-core/helpers/json";
+import { map } from "rxjs";
+import { getChannelMetadataContent } from "../helpers/channels.js";
+/** A model that returns a map of hidden messages Map<id, reason> */
+export function ChannelHiddenModel(channel, authors = []) {
+    return (events) => {
+        const hidden = new Map();
+        return events
+            .filters([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+            .pipe(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;
+        }));
+    };
+}
+/** A model that returns all messages in a channel */
+export function ChannelMessagesModel(channel) {
+    return (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]);
+}
+/** A model that returns the latest parsed metadata */
+export function ChannelMetadataModel(channel) {
+    return (events) => {
+        const filters = [
+            { ids: [channel.id] },
+            { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
+        ];
+        let latest = channel;
+        return events.filters(filters).pipe(map((event) => {
+            try {
+                if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                    latest = event;
+                }
+                return getChannelMetadataContent(latest);
+            }
+            catch (error) {
+                return undefined;
+            }
+        }));
+    };
+}
+/** A model that returns a map of muted users Map<pubkey, reason> */
+export function ChannelMutedModel(channel, authors = []) {
+    return (events) => {
+        const muted = new Map();
+        return events
+            .filters([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+            .pipe(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;
+        }));
+    };
+}

package/dist/models/comments.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { type Observable } from "rxjs";
+/** A model that returns all NIP-22 comment replies for the event */
+export declare function CommentsModel(parent: NostrEvent): Model<NostrEvent[]>;
+declare module "applesauce-core/event-store" {
+    interface EventModels {
+        /** Subscribe to an event's comments */
+        comments(event: NostrEvent): Observable<NostrEvent[]>;
+    }
+}

package/dist/models/comments.js

@@ -0,0 +1,17 @@
+import { getReplaceableAddress, isAddressableKind } from "applesauce-core/helpers/event";
+import { COMMENT_KIND } from "../helpers/comment.js";
+// Import EventModels as a value (class) to modify its prototype
+import { EventModels } from "applesauce-core/event-store";
+/** A model that returns all NIP-22 comment replies for the event */
+export function CommentsModel(parent) {
+    return (events) => {
+        const filters = [{ kinds: [COMMENT_KIND], "#e": [parent.id] }];
+        if (isAddressableKind(parent.kind))
+            filters.push({ kinds: [COMMENT_KIND], "#a": [getReplaceableAddress(parent)] });
+        return events.timeline(filters);
+    };
+}
+// Register this model with EventModels
+EventModels.prototype.comments = function (event) {
+    return this.model(CommentsModel, event);
+};

package/dist/models/gift-wrap.d.ts

@@ -0,0 +1,7 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { Rumor } from "../helpers/gift-wrap.js";
+/** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
+export declare function GiftWrapsModel(pubkey: string, unlocked?: boolean): Model<NostrEvent[]>;
+/** A model that returns the rumor event of a gift wrap event when its unlocked */
+export declare function GiftWrapRumorModel(gift: NostrEvent | string): Model<Rumor | undefined>;

package/dist/models/gift-wrap.js

@@ -0,0 +1,20 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { watchEventsUpdates, watchEventUpdates } from "applesauce-core/observable";
+import { identity, map, of } from "rxjs";
+import { getGiftWrapRumor, isGiftWrapUnlocked } from "../helpers/gift-wrap.js";
+/** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
+export function GiftWrapsModel(pubkey, unlocked) {
+    return (store) => store.timeline({ kinds: [kinds.GiftWrap], "#p": [pubkey] }).pipe(
+    // Update the timeline when events are updated
+    watchEventsUpdates(store), 
+    // If unlock is specified filter on unlocked status
+    unlocked !== undefined ? map((events) => events.filter((e) => isGiftWrapUnlocked(e) === unlocked)) : identity);
+}
+/** A model that returns the rumor event of a gift wrap event when its unlocked */
+export function GiftWrapRumorModel(gift) {
+    return (events) => (typeof gift === "string" ? events.event(gift) : of(gift)).pipe(
+    // Listen for updates to the event
+    watchEventUpdates(events), 
+    // Get the rumor event
+    map((event) => event && getGiftWrapRumor(event)));
+}

package/dist/models/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./blossom.js";
+export * from "./bookmarks.js";
+export * from "./calendar.js";
+export * from "./channels.js";
+export * from "./comments.js";
+export * from "./legacy-messages.js";
+export * from "./mutes.js";
+export * from "./pins.js";
+export * from "./reactions.js";
+export * from "./thread.js";
+export * from "./user-status.js";
+export * from "./wrapped-messages.js";
+export * from "./zaps.js";
+export * from "./gift-wrap.js";
+import "../register.js";

package/dist/models/index.js

@@ -0,0 +1,16 @@
+export * from "./blossom.js";
+export * from "./bookmarks.js";
+export * from "./calendar.js";
+export * from "./channels.js";
+export * from "./comments.js";
+export * from "./legacy-messages.js";
+export * from "./mutes.js";
+export * from "./pins.js";
+export * from "./reactions.js";
+export * from "./thread.js";
+export * from "./user-status.js";
+export * from "./wrapped-messages.js";
+export * from "./zaps.js";
+export * from "./gift-wrap.js";
+// Register the common models with the event store
+import "../register.js";

package/dist/models/legacy-messages.d.ts

@@ -0,0 +1,14 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+/** A model that returns all legacy message groups (1-1) that a pubkey is participating in */
+export declare function LegacyMessagesGroups(self: string): Model<{
+    id: string;
+    participants: string[];
+    lastMessage: NostrEvent;
+}[]>;
+/** Returns all legacy direct messages in a group */
+export declare function LegacyMessagesGroup(self: string, correspondent: string): Model<NostrEvent[]>;
+/** Returns an array of legacy messages that have replies */
+export declare function LegacyMessageThreads(self: string, correspondent: string): Model<NostrEvent[]>;
+/** Returns all the legacy direct messages that are replies to a given message */
+export declare function LegacyMessageReplies(self: string, message: NostrEvent): Model<NostrEvent[]>;

package/dist/models/legacy-messages.js

@@ -0,0 +1,64 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { hasNameValueTag } from "applesauce-core/helpers/event";
+import { map } from "rxjs";
+import { getLegacyMessageCorrespondent, getLegacyMessageParent } from "../helpers/legacy-messages.js";
+import { getConversationIdentifierFromMessage, getConversationParticipants } from "../helpers/messages.js";
+/** A model that returns all legacy message groups (1-1) that a pubkey is participating in */
+export function LegacyMessagesGroups(self) {
+    return (store) => store.timeline({ kinds: [kinds.EncryptedDirectMessage], "#p": [self] }).pipe(map((messages) => {
+        const groups = {};
+        for (const message of messages) {
+            const id = getConversationIdentifierFromMessage(message);
+            if (!groups[id] || groups[id].created_at < message.created_at)
+                groups[id] = message;
+        }
+        return Object.values(groups).map((message) => ({
+            id: getConversationIdentifierFromMessage(message),
+            participants: getConversationParticipants(message),
+            lastMessage: message,
+        }));
+    }));
+}
+/** Returns all legacy direct messages in a group */
+export function LegacyMessagesGroup(self, correspondent) {
+    return (store) => store.timeline([
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [self],
+            authors: [correspondent],
+        },
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [correspondent],
+            authors: [self],
+        },
+    ]);
+}
+/** Returns an array of legacy messages that have replies */
+export function LegacyMessageThreads(self, correspondent) {
+    return (store) => store.model(LegacyMessagesGroup, self, correspondent).pipe(map((messages) => messages.filter((message) => 
+    // Only select messages that are not replies
+    !getLegacyMessageParent(message) &&
+        // Check if message has any replies
+        messages.some((m) => hasNameValueTag(m, "e", message.id)))));
+}
+/** Returns all the legacy direct messages that are replies to a given message */
+export function LegacyMessageReplies(self, message) {
+    const correspondent = getLegacyMessageCorrespondent(message, self);
+    if (!correspondent)
+        throw new Error("Legacy message has no correspondent");
+    return (store) => store.timeline([
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [self],
+            authors: [correspondent],
+            "#e": [message.id],
+        },
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [correspondent],
+            authors: [self],
+            "#e": [message.id],
+        },
+    ]);
+}

package/dist/models/mutes.d.ts

@@ -0,0 +1,16 @@
+import { Model } from "applesauce-core/event-store";
+import { ProfilePointer } from "applesauce-core/helpers/pointers";
+import { type Observable } from "rxjs";
+import { Mutes } from "../helpers/mute.js";
+/** A model that returns all a users muted things */
+export declare function MuteModel(user: string | ProfilePointer): Model<Mutes | undefined>;
+/** A model that returns all a users public muted things */
+export declare function PublicMuteModel(pubkey: string): Model<Mutes | undefined>;
+/** A model that returns all a users hidden muted things */
+export declare function HiddenMuteModel(pubkey: string): Model<Mutes | null | undefined>;
+declare module "applesauce-core/event-store" {
+    interface EventModels {
+        /** Subscribe to a users mutes */
+        mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
+    }
+}

package/dist/models/mutes.js

@@ -0,0 +1,34 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { watchEventUpdates } from "applesauce-core/observable";
+import { map } from "rxjs/operators";
+import { getHiddenMutedThings, getMutedThings, getPublicMutedThings } from "../helpers/mute.js";
+// Import EventModels as a value (class) to modify its prototype
+import { EventModels } from "applesauce-core/event-store";
+/** A model that returns all a users muted things */
+export function MuteModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.Mutelist, pubkey: user.pubkey, relays: user.relays }).pipe(
+    // listen for event updates (hidden tags unlocked)
+    watchEventUpdates(events), 
+    // Get all muted things
+    map((event) => event && getMutedThings(event)));
+}
+/** A model that returns all a users public muted things */
+export function PublicMuteModel(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicMutedThings(event)));
+}
+/** A model that returns all a users hidden muted things */
+export function HiddenMuteModel(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    watchEventUpdates(events), 
+    // Get hidden muted things
+    map((event) => event && getHiddenMutedThings(event)));
+}
+// Register this model with EventModels
+EventModels.prototype.mutes = function (user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return this.model(MuteModel, user);
+};

package/dist/models/pins.d.ts

@@ -0,0 +1,4 @@
+import { Model } from "applesauce-core/event-store";
+import { EventPointer } from "applesauce-core/helpers/pointers";
+/** A model that returns all pinned pointers for a user */
+export declare function UserPinnedModel(pubkey: string): Model<EventPointer[] | undefined>;

package/dist/models/pins.js

@@ -0,0 +1,10 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { getEventPointerFromETag } from "applesauce-core/helpers/pointers";
+import { isETag, processTags } from "applesauce-core/helpers/tags";
+import { map } from "rxjs/operators";
+/** A model that returns all pinned pointers for a user */
+export function UserPinnedModel(pubkey) {
+    return (events) => events
+        .replaceable(kinds.Pinlist, pubkey)
+        .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag)));
+}

package/dist/models/reactions.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { Model } from "applesauce-core/event-store";
+import { type Observable } from "rxjs";
+/** A model that returns all reactions to an event (supports replaceable events) */
+export declare function ReactionsModel(event: NostrEvent): Model<NostrEvent[]>;
+declare module "applesauce-core/event-store" {
+    interface EventModels {
+        /** Subscribe to an event's reactions */
+        reactions(event: NostrEvent): Observable<NostrEvent[]>;
+    }
+}

package/dist/models/reactions.js

@@ -0,0 +1,21 @@
+import { getEventUID, isReplaceable, kinds } from "applesauce-core/helpers/event";
+// Import EventModels as a value (class) to modify its prototype
+import { EventModels } from "applesauce-core/event-store";
+/** A model that returns all reactions to an event (supports replaceable events) */
+export function ReactionsModel(event) {
+    return (events) => events.timeline(isReplaceable(event.kind)
+        ? [
+            { kinds: [kinds.Reaction], "#e": [event.id] },
+            { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
+        ]
+        : [
+            {
+                kinds: [kinds.Reaction],
+                "#e": [event.id],
+            },
+        ]);
+}
+// Register this model with EventModels
+EventModels.prototype.reactions = function (event) {
+    return this.model(ReactionsModel, event);
+};

package/dist/models/thread.d.ts

@@ -0,0 +1,33 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+import { type Observable } from "rxjs";
+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 ThreadModelOptions = {
+    kinds?: number[];
+};
+/** A model that returns a NIP-10 thread of events */
+export declare function ThreadModel(root: string | AddressPointer | EventPointer, opts?: ThreadModelOptions): Model<Thread>;
+/** A model that gets all legacy and NIP-10, and NIP-22 replies for an event */
+export declare function RepliesModel(event: NostrEvent, overrideKinds?: number[]): Model<NostrEvent[]>;
+declare module "applesauce-core/event-store" {
+    interface EventModels {
+        /** Subscribe to a thread */
+        thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
+    }
+}

package/dist/models/thread.js

@@ -0,0 +1,93 @@
+import { createReplaceableAddress, getEventUID, isEvent, kinds } from "applesauce-core/helpers/event";
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer, } from "applesauce-core/helpers/pointers";
+import { isAddressableKind } from "applesauce-core/helpers/event";
+import { map } from "rxjs/operators";
+import { COMMENT_KIND } from "../helpers/comment.js";
+import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
+// Import EventModels as a value (class) to modify its prototype
+import { EventModels } from "applesauce-core/event-store";
+const defaultOptions = {
+    kinds: [kinds.ShortTextNote],
+};
+/** A model that returns a NIP-10 thread of events */
+export function ThreadModel(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 (events) => events.filters([rootFilter, replyFilter]).pipe(map((event) => {
+        if (!items.has(getEventUID(event))) {
+            const refs = getNip10References(event);
+            const replies = parentReferences.get(getEventUID(event)) || new Set();
+            const item = { event, refs, replies };
+            for (const child of replies) {
+                child.parent = item;
+            }
+            // add item to parent
+            if (refs.reply?.e || refs.reply?.a) {
+                let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
+                item.parent = items.get(uid);
+                if (item.parent) {
+                    item.parent.replies.add(item);
+                }
+                else {
+                    // parent isn't created yet, store ref for later
+                    let set = parentReferences.get(uid);
+                    if (!set) {
+                        set = new Set();
+                        parentReferences.set(uid, set);
+                    }
+                    set.add(item);
+                }
+            }
+            // add item to map
+            items.set(getEventUID(event), item);
+        }
+        return { root: items.get(rootUID), all: items };
+    }));
+}
+/** A model that gets all legacy and NIP-10, and NIP-22 replies for an event */
+export function RepliesModel(event, overrideKinds) {
+    return (events) => {
+        const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
+        const filter = { kinds };
+        if (isEvent(parent) || isEventPointer(event))
+            filter["#e"] = [event.id];
+        const address = isAddressableKind(event.kind)
+            ? createReplaceableAddress(event.kind, event.pubkey, getTagValue(event, "d"))
+            : undefined;
+        if (address) {
+            filter["#a"] = [address];
+        }
+        return events.timeline(filter).pipe(map((events) => {
+            return events.filter((e) => {
+                const refs = interpretThreadTags(e.tags);
+                return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
+            });
+        }));
+    };
+}
+// Register this model with EventModels
+EventModels.prototype.thread = function (root) {
+    return this.model(ThreadModel, root);
+};

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

@@ -0,0 +1,11 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { UserStatusPointer } from "../helpers/user-status.js";
+export type UserStatus = UserStatusPointer & {
+    event: NostrEvent;
+    content: string;
+};
+/** A model that returns a parsed {@link UserStatus} for a certain type */
+export declare function UserStatusModel(pubkey: string, type?: string): Model<UserStatus | undefined | null>;
+/** A model that returns a directory of parsed {@link UserStatus} for a pubkey */
+export declare function UserStatusesModel(pubkey: string): Model<Record<string, UserStatus>>;

package/dist/models/user-status.js

@@ -0,0 +1,32 @@
+import { getReplaceableIdentifier, kinds } from "applesauce-core/helpers/event";
+import { map } from "rxjs";
+import { getUserStatusPointer } from "../helpers/user-status.js";
+/** A model that returns a parsed {@link UserStatus} for a certain type */
+export function UserStatusModel(pubkey, type = "general") {
+    return (events) => events.replaceable(kinds.UserStatuses, pubkey, type).pipe(map((event) => {
+        if (!event)
+            return undefined;
+        const pointer = getUserStatusPointer(event);
+        if (!pointer)
+            return null;
+        return {
+            ...pointer,
+            event,
+            content: event.content,
+        };
+    }));
+}
+/** A model that returns a directory of parsed {@link UserStatus} for a pubkey */
+export function UserStatusesModel(pubkey) {
+    return (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).pipe(map((events) => {
+        return events.reduce((dir, event) => {
+            try {
+                const d = getReplaceableIdentifier(event);
+                return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
+            }
+            catch (error) {
+                return dir;
+            }
+        }, {});
+    }));
+}

package/dist/models/wrapped-messages.d.ts

@@ -0,0 +1,31 @@
+import { Model } from "applesauce-core/event-store";
+import { Rumor } from "../helpers/gift-wrap.js";
+/**
+ * A model that returns all wrapped messages for a pubkey
+ * @param self - The pubkey of the user
+ */
+export declare function WrappedMessagesModel(self: string): Model<Rumor[]>;
+/** A model that returns all conversations that a pubkey is participating in */
+export declare function WrappedMessagesGroups(self: string): Model<{
+    id: string;
+    participants: string[];
+    lastMessage: Rumor;
+}[]>;
+/**
+ * A model that returns all wrapped direct messages in a conversation
+ * @param self - The pubkey of the user
+ * @param participants - A conversation identifier or a list of participant pubkeys
+ */
+export declare function WrappedMessagesGroup(self: string, participants: string | string[]): Model<Rumor[]>;
+/**
+ * Returns an array of root wrapped messages that have replies
+ * @param self - The pubkey of the user
+ * @param participants - A conversation identifier or a list of participant pubkeys
+ */
+export declare function WrappedMessageThreads(self: string, participants: string | string[]): Model<Rumor[]>;
+/**
+ * A model that returns all the gift wrapped direct messages that are replies to a given message
+ * @param self - The pubkey of the user
+ * @param message - The message to get the replies for
+ */
+export declare function WrappedMessageReplies(self: string, message: Rumor): Model<Rumor[]>;

package/dist/models/wrapped-messages.js

@@ -0,0 +1,76 @@
+import { watchEventsUpdates } from "applesauce-core/observable";
+import { kinds } from "applesauce-core/helpers/event";
+import { map } from "rxjs";
+import { getGiftWrapRumor } from "../helpers/gift-wrap.js";
+import { createConversationIdentifier, getConversationIdentifierFromMessage, getConversationParticipants, } from "../helpers/messages.js";
+import { getWrappedMessageParent } from "../helpers/wrapped-messages.js";
+/**
+ * A model that returns all wrapped messages for a pubkey
+ * @param self - The pubkey of the user
+ */
+export function WrappedMessagesModel(self) {
+    return (store) => store.timeline({ kinds: [kinds.GiftWrap], "#p": [self] }).pipe(
+    // Watch for updates to the gift wraps
+    watchEventsUpdates(store), 
+    // Get rumors and filter out locked
+    map((rumors) => rumors
+        .map((gift) => getGiftWrapRumor(gift))
+        .filter((e) => !!e)
+        .filter((e) => e.kind === kinds.PrivateDirectMessage)
+        .sort((a, b) => b.created_at - a.created_at)));
+}
+/** A model that returns all conversations that a pubkey is participating in */
+export function WrappedMessagesGroups(self) {
+    return (store) => store.model(WrappedMessagesModel, self).pipe(map((messages) => {
+        const groups = {};
+        for (const message of messages) {
+            const id = getConversationIdentifierFromMessage(message);
+            if (!groups[id] || groups[id].created_at < message.created_at)
+                groups[id] = message;
+        }
+        return Object.values(groups).map((message) => ({
+            id: getConversationIdentifierFromMessage(message),
+            participants: getConversationParticipants(message),
+            lastMessage: message,
+        }));
+    }));
+}
+/**
+ * A model that returns all wrapped direct messages in a conversation
+ * @param self - The pubkey of the user
+ * @param participants - A conversation identifier or a list of participant pubkeys
+ */
+export function WrappedMessagesGroup(self, participants) {
+    // Get the conversation identifier include the users pubkey
+    const identifier = createConversationIdentifier(self, participants);
+    return (store) => store.model(WrappedMessagesModel, self).pipe(
+    // Only select direct messages for this conversation
+    map((rumors) => rumors.filter((rumor) => rumor.kind === kinds.PrivateDirectMessage &&
+        // Only select message for this conversation (the identifier from the message will include "self")
+        getConversationIdentifierFromMessage(rumor) === identifier)));
+}
+/**
+ * Returns an array of root wrapped messages that have replies
+ * @param self - The pubkey of the user
+ * @param participants - A conversation identifier or a list of participant pubkeys
+ */
+export function WrappedMessageThreads(self, participants) {
+    return (store) => store.model(WrappedMessagesGroup, self, participants).pipe(
+    // Filter down messages to only include root messages that have replies
+    map((rumors) => rumors.filter((rumor) => 
+    // Only select root messages
+    !getWrappedMessageParent(rumor) &&
+        // Check if message has any replies
+        rumors.some((r) => getWrappedMessageParent(r) === rumor.id))));
+}
+/**
+ * A model that returns all the gift wrapped direct messages that are replies to a given message
+ * @param self - The pubkey of the user
+ * @param message - The message to get the replies for
+ */
+export function WrappedMessageReplies(self, message) {
+    const conversation = getConversationIdentifierFromMessage(message);
+    return (store) => store.model(WrappedMessagesGroup, self, conversation).pipe(
+    // Only select replies to this message
+    map((rumors) => rumors.filter((rumor) => getWrappedMessageParent(rumor) === message.id)));
+}

package/dist/models/zaps.d.ts

@@ -0,0 +1,9 @@
+import { Model } from "applesauce-core/event-store";
+import { KnownEvent, kinds } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+/** A model that gets all zap events for an event */
+export declare function EventZapsModel(id: string | EventPointer | AddressPointer): Model<KnownEvent<kinds.Zap>[]>;
+/** A model that returns all zaps sent by a user */
+export declare function SentZapsModel(pubkey: string): Model<KnownEvent<kinds.Zap>[]>;
+/** A model that returns all zaps received by a user */
+export declare function ReceivedZapsModel(pubkey: string): Model<KnownEvent<kinds.Zap>[]>;