applesauce-common 0.0.0-next-20251203172109

package/dist/helpers/torrent.js

@@ -0,0 +1,270 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getTagValue } from "applesauce-core/helpers/event";
+export const TORRENT_KIND = 2003;
+const TorrentInfoHashSymbol = Symbol.for("torrent-info-hash");
+const TorrentTitleSymbol = Symbol.for("torrent-title");
+const TorrentFilesSymbol = Symbol.for("torrent-files");
+const TorrentTrackersSymbol = Symbol.for("torrent-trackers");
+const TorrentCategorySymbol = Symbol.for("torrent-category");
+const TorrentSearchTagsSymbol = Symbol.for("torrent-search-tags");
+const TorrentCategoryPathSymbol = Symbol.for("torrent-category-path");
+const TorrentExternalIdentifiersSymbol = Symbol.for("torrent-external-identifiers");
+const TorrentMagnetLinkSymbol = Symbol.for("torrent-magnet-link");
+export function getTorrentInfoHash(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return undefined;
+    return getOrComputeCachedValue(torrent, TorrentInfoHashSymbol, () => {
+        return getTagValue(torrent, "x");
+    });
+}
+/** Returns the torrent title from the `title` tag */
+export function getTorrentTitle(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return undefined;
+    return getOrComputeCachedValue(torrent, TorrentTitleSymbol, () => {
+        return getTagValue(torrent, "title");
+    });
+}
+/** Returns all file entries from `file` tags */
+export function getTorrentFiles(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return [];
+    return getOrComputeCachedValue(torrent, TorrentFilesSymbol, () => {
+        const files = [];
+        for (const tag of torrent.tags) {
+            if (tag[0] === "file" && tag[1]) {
+                const file = {
+                    name: tag[1],
+                };
+                // Optional size in bytes (tag[2])
+                if (tag[2]) {
+                    const size = parseInt(tag[2], 10);
+                    if (!Number.isNaN(size)) {
+                        file.size = size;
+                    }
+                }
+                files.push(file);
+            }
+        }
+        return files;
+    });
+}
+/** Returns all tracker URLs from `tracker` tags */
+export function getTorrentTrackers(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return [];
+    return getOrComputeCachedValue(torrent, TorrentTrackersSymbol, () => {
+        const trackers = [];
+        for (const tag of torrent.tags) {
+            if (tag[0] === "tracker" && tag[1])
+                trackers.push(tag[1]);
+        }
+        return trackers;
+    });
+}
+/** Returns the newznab category ID from the `i` tag with `newznab:` prefix */
+export function getTorrentCategory(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return undefined;
+    return getOrComputeCachedValue(torrent, TorrentCategorySymbol, () => {
+        for (const tag of torrent.tags) {
+            if (tag[0] === "i" && tag[1]?.startsWith("newznab:")) {
+                const categoryId = parseInt(tag[1].slice(8), 10); // Return the ID after "newznab:"
+                if (!Number.isNaN(categoryId)) {
+                    return categoryId;
+                }
+            }
+        }
+        return undefined;
+    });
+}
+/** Returns all search tags (for searchability) from `t` tags */
+export function getTorrentSearchTags(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return [];
+    return getOrComputeCachedValue(torrent, TorrentSearchTagsSymbol, () => {
+        const tags = [];
+        for (const tag of torrent.tags) {
+            if (tag[0] === "t" && tag[1])
+                tags.push(tag[1]);
+        }
+        return tags;
+    });
+}
+/** Returns the category path from the `tcat` identifier in `i` tags (e.g., "video,movie,4k") */
+export function getTorrentCategoryPath(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return undefined;
+    return getOrComputeCachedValue(torrent, TorrentCategoryPathSymbol, () => {
+        for (const tag of torrent.tags) {
+            if (tag[0] === "i" && tag[1]?.startsWith("tcat:")) {
+                return tag[1].slice(5); // Return the path after "tcat:"
+            }
+        }
+        return undefined;
+    });
+}
+/**
+ * Parses an external identifier from an `i` tag value
+ * Supports prefixes: tmdb, ttvdb, imdb, mal, anilist
+ * Supports second-level prefixes: tmdb:movie, ttvdb:movie, mal:anime, mal:manga
+ * Note: tcat is excluded as it's handled separately via getTorrentCategoryPath
+ * Note: newznab is excluded as it's handled separately via getTorrentCategory
+ */
+function parseTorrentExternalIdentifier(value) {
+    // Skip tcat - it's handled separately as a category path
+    if (value.startsWith("tcat:"))
+        return null;
+    // Skip newznab - it's handled separately as categories
+    if (value.startsWith("newznab:"))
+        return null;
+    // tmdb:movie:693134 or tmdb:693134
+    if (value.startsWith("tmdb:")) {
+        const rest = value.slice(5);
+        const parts = rest.split(":");
+        if (parts.length === 2) {
+            return {
+                prefix: "tmdb",
+                identifier: value,
+                mediaType: parts[0],
+                id: parts[1],
+            };
+        }
+        else {
+            return {
+                prefix: "tmdb",
+                identifier: value,
+                id: rest,
+            };
+        }
+    }
+    // ttvdb:movie:290272 or ttvdb:290272
+    if (value.startsWith("ttvdb:")) {
+        const rest = value.slice(6);
+        const parts = rest.split(":");
+        if (parts.length === 2) {
+            return {
+                prefix: "ttvdb",
+                identifier: value,
+                mediaType: parts[0],
+                id: parts[1],
+            };
+        }
+        else {
+            return {
+                prefix: "ttvdb",
+                identifier: value,
+                id: rest,
+            };
+        }
+    }
+    // imdb:tt15239678
+    if (value.startsWith("imdb:")) {
+        return {
+            prefix: "imdb",
+            identifier: value,
+            id: value.slice(5),
+        };
+    }
+    // mal:anime:9253 or mal:manga:17517 or mal:9253
+    if (value.startsWith("mal:")) {
+        const rest = value.slice(4);
+        const parts = rest.split(":");
+        if (parts.length === 2) {
+            return {
+                prefix: "mal",
+                identifier: value,
+                mediaType: parts[0],
+                id: parts[1],
+            };
+        }
+        else {
+            return {
+                prefix: "mal",
+                identifier: value,
+                id: rest,
+            };
+        }
+    }
+    // anilist:12345
+    if (value.startsWith("anilist:")) {
+        return {
+            prefix: "anilist",
+            identifier: value,
+            id: value.slice(8),
+        };
+    }
+    return null;
+}
+/** Returns all external identifiers from `i` tags (excluding tcat and newznab, which are handled separately) */
+export function getTorrentExternalIdentifiers(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return [];
+    return getOrComputeCachedValue(torrent, TorrentExternalIdentifiersSymbol, () => {
+        const identifiers = [];
+        for (const tag of torrent.tags) {
+            if (tag[0] === "i" && tag[1]) {
+                const parsed = parseTorrentExternalIdentifier(tag[1]);
+                if (parsed) {
+                    identifiers.push(parsed);
+                }
+            }
+        }
+        return identifiers;
+    });
+}
+/**
+ * Creates a TorrentExternalIdentifier object from prefix, id, and optional mediaType
+ * Automatically constructs the full identifier string
+ */
+export function createTorrentExternalIdentifier(prefix, id, mediaType) {
+    let identifier;
+    // Build identifier string based on prefix and whether mediaType is provided
+    if (mediaType) {
+        // For prefixes that support mediaType: tmdb, ttvdb, mal
+        identifier = `${prefix}:${mediaType}:${id}`;
+    }
+    else {
+        // Simple format: prefix:id
+        identifier = `${prefix}:${id}`;
+    }
+    return {
+        prefix,
+        identifier,
+        mediaType,
+        id,
+    };
+}
+/**
+ * Builds a magnet link from an info hash, optional trackers, and optional name
+ * Format: magnet:?xt=urn:btih:${infoHash}${trackers ? '&tr=' + trackers.join('&tr=') : ''}${name ? '&dn=' + encodeURIComponent(name) : ''}
+ */
+export function buildTorrentMagnetLink(infoHash, trackers, name) {
+    const parts = [`magnet:?xt=urn:btih:${infoHash}`];
+    if (trackers && trackers.length > 0) {
+        for (const tracker of trackers) {
+            parts.push(`&tr=${encodeURIComponent(tracker)}`);
+        }
+    }
+    if (name) {
+        parts.push(`&dn=${encodeURIComponent(name)}`);
+    }
+    return parts.join("");
+}
+/** Returns the magnet link for a torrent, building it from the event if needed */
+export function getTorrentMagnetLink(torrent) {
+    if (torrent.kind !== TORRENT_KIND)
+        return undefined;
+    return getOrComputeCachedValue(torrent, TorrentMagnetLinkSymbol, () => {
+        const infoHash = getTorrentInfoHash(torrent);
+        if (!infoHash)
+            return undefined;
+        const trackers = getTorrentTrackers(torrent);
+        const title = getTorrentTitle(torrent);
+        return buildTorrentMagnetLink(infoHash, trackers.length > 0 ? trackers : undefined, title);
+    });
+}
+/** Validates that an event is a valid torrent event (kind 2003 with required `x` tag) */
+export function isValidTorrent(torrent) {
+    return torrent.kind === TORRENT_KIND && getTorrentInfoHash(torrent) !== undefined;
+}

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

@@ -0,0 +1,18 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer, ProfilePointer } from "applesauce-core/helpers/pointers";
+export declare const UserStatusPointerSymbol: unique symbol;
+export type UserStatusPointer = {
+    type: "nevent";
+    data: EventPointer;
+} | {
+    type: "nprofile";
+    data: ProfilePointer;
+} | {
+    type: "naddr";
+    data: AddressPointer;
+} | {
+    type: "url";
+    data: string;
+};
+/** Gets the {@link UserStatusPointer} for a status event */
+export declare function getUserStatusPointer(status: NostrEvent): UserStatusPointer | null;

package/dist/helpers/user-status.js

@@ -0,0 +1,22 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag, } from "applesauce-core/helpers/pointers";
+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: getProfilePointerFromPTag(pTag) };
+    const eTag = status.tags.find((t) => t[0] === "e" && t[1]);
+    if (eTag)
+        return { type: "nevent", data: getEventPointerFromETag(eTag) };
+    const aTag = status.tags.find((t) => t[0] === "a" && t[1]);
+    if (aTag)
+        return { type: "naddr", data: getAddressPointerFromATag(aTag) };
+    const rTag = status.tags.find((t) => t[0] === "r" && t[1]);
+    if (rTag)
+        return { type: "url", data: rTag[1] };
+    return null;
+}
+/** Gets the {@link UserStatusPointer} for a status event */
+export function getUserStatusPointer(status) {
+    return getOrComputeCachedValue(status, UserStatusPointerSymbol, () => getStatusPointer(status));
+}

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

@@ -0,0 +1,14 @@
+import { Rumor } from "./gift-wrap.js";
+/** Returns the subject of a wrapped direct message */
+export declare function getWrappedMessageSubject(message: Rumor): string | undefined;
+/** Returns the parent id of a wrapped direct message */
+export declare function getWrappedMessageParent(message: Rumor): string | undefined;
+/** Returns the sender of a wrapped direct message */
+export declare function getWrappedMessageSender(message: Rumor): string;
+/** @deprecated use {@link getWrappedMessageSender} instead */
+export declare const getWrappedMesssageSender: typeof getWrappedMessageSender;
+/**
+ * Returns the first participant in a conversation that is not the sender
+ * @see getConversationParticipants
+ */
+export declare function getWrappedMessageReceiver(message: Rumor): string;

package/dist/helpers/wrapped-messages.js

@@ -0,0 +1,23 @@
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getConversationParticipants } from "./messages.js";
+/** Returns the subject of a wrapped direct message */
+export function getWrappedMessageSubject(message) {
+    return getTagValue(message, "subject");
+}
+/** Returns the parent id of a wrapped direct message */
+export function getWrappedMessageParent(message) {
+    return getTagValue(message, "e");
+}
+/** Returns the sender of a wrapped direct message */
+export function getWrappedMessageSender(message) {
+    return message.pubkey;
+}
+/** @deprecated use {@link getWrappedMessageSender} instead */
+export const getWrappedMesssageSender = getWrappedMessageSender;
+/**
+ * Returns the first participant in a conversation that is not the sender
+ * @see getConversationParticipants
+ */
+export function getWrappedMessageReceiver(message) {
+    return getConversationParticipants(message).filter((p) => p !== message.pubkey)[0];
+}

package/dist/helpers/zap.d.ts

@@ -0,0 +1,46 @@
+import { KnownEvent } from "applesauce-core/helpers/event";
+import { kinds, NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+import { ParsedInvoice } from "./bolt11.js";
+/** Type for validated zap event */
+export type ZapEvent = KnownEvent<kinds.Zap>;
+export declare const ZapRequestSymbol: unique symbol;
+export declare const ZapSenderSymbol: unique symbol;
+export declare const ZapReceiverSymbol: unique symbol;
+export declare const ZapInvoiceSymbol: unique symbol;
+export declare const ZapEventPointerSymbol: unique symbol;
+export declare const ZapAddressPointerSymbol: unique symbol;
+/** Returns the senders pubkey */
+export declare function getZapSender(zap: ZapEvent): string;
+export declare function getZapSender(zap: NostrEvent): string | undefined;
+/** Gets the receivers pubkey */
+export declare function getZapRecipient(zap: ZapEvent): string;
+export declare function getZapRecipient(zap: NostrEvent): string | undefined;
+/** Returns the parsed bolt11 invoice */
+export declare function getZapPayment(zap: ZapEvent): ParsedInvoice;
+export declare function getZapPayment(zap: NostrEvent): ParsedInvoice | undefined;
+/** Returns the zap event amount in msats */
+export declare function getZapAmount(zap: ZapEvent): number;
+export declare function getZapAmount(zap: NostrEvent): number | undefined;
+/** Gets the AddressPointer that was zapped */
+export declare function getZapAddressPointer(zap: NostrEvent): AddressPointer | null;
+/** Gets the EventPointer that was zapped */
+export declare function getZapEventPointer(zap: NostrEvent): EventPointer | null;
+/** Gets the preimage for the bolt11 invoice */
+export declare function getZapPreimage(zap: NostrEvent): string | undefined;
+/** Returns the zap request event inside the zap receipt */
+export declare function getZapRequest(zap: ZapEvent): NostrEvent;
+export declare function getZapRequest(zap: NostrEvent): NostrEvent | undefined;
+/**
+ * Checks if a zap event is valid (not missing fields)
+ * DOES NOT validate LNURL address
+ */
+export declare function isValidZap(zap?: NostrEvent): zap is ZapEvent;
+export type ZapSplit = {
+    pubkey: string;
+    percent: number;
+    weight: number;
+    relay?: string;
+};
+/** Returns the zap splits for an event */
+export declare function getZapSplits(event: NostrEvent): ZapSplit[] | undefined;

package/dist/helpers/zap.js

@@ -0,0 +1,125 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { isEvent, verifyWrappedEvent } from "applesauce-core/helpers/event";
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "applesauce-core/helpers/pointers";
+import { isATag, isETag } from "applesauce-core/helpers/tags";
+import { kinds } from "applesauce-core/helpers/event";
+import { parseBolt11 } from "./bolt11.js";
+export const ZapRequestSymbol = Symbol.for("zap-request");
+export const ZapSenderSymbol = Symbol.for("zap-sender");
+export const ZapReceiverSymbol = Symbol.for("zap-receiver");
+export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
+export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
+export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
+export function getZapSender(zap) {
+    return getOrComputeCachedValue(zap, ZapSenderSymbol, () => {
+        return getTagValue(zap, "P") || getZapRequest(zap)?.pubkey;
+    });
+}
+export function getZapRecipient(zap) {
+    return getOrComputeCachedValue(zap, ZapReceiverSymbol, () => {
+        return getTagValue(zap, "p");
+    });
+}
+export function getZapPayment(zap) {
+    return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
+        const bolt11 = getTagValue(zap, "bolt11");
+        try {
+            // Catch errors with parsing the bolt11 invoice
+            return bolt11 ? parseBolt11(bolt11) : undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
+    });
+}
+export function getZapAmount(zap) {
+    return getZapPayment(zap)?.amount;
+}
+/** Gets the AddressPointer that was zapped */
+export function getZapAddressPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
+        const a = zap.tags.find(isATag);
+        return a ? getAddressPointerFromATag(a) : null;
+    });
+}
+/** Gets the EventPointer that was zapped */
+export function getZapEventPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapEventPointerSymbol, () => {
+        const e = zap.tags.find(isETag);
+        return e ? getEventPointerFromETag(e) : null;
+    });
+}
+/** Gets the preimage for the bolt11 invoice */
+export function getZapPreimage(zap) {
+    return getTagValue(zap, "preimage");
+}
+export function getZapRequest(zap) {
+    return getOrComputeCachedValue(zap, ZapRequestSymbol, () => {
+        const description = getTagValue(zap, "description");
+        if (!description)
+            return;
+        // Attempt to parse the zap request
+        try {
+            // Copied from nostr-tools/nip57 and modified to use the internal verifyZap method and return the zap request event
+            let zapRequest;
+            try {
+                zapRequest = JSON.parse(description);
+            }
+            catch (err) {
+                throw new Error("Invalid zap request JSON.");
+            }
+            if (!isEvent(zapRequest))
+                throw new Error("Zap request is not a valid Nostr event.");
+            if (!verifyWrappedEvent(zapRequest))
+                throw new Error("Invalid signature on zap request.");
+            let p = zapRequest.tags.find(([t, v]) => t === "p" && v);
+            if (!p)
+                throw new Error("Zap request doesn't have a 'p' tag.");
+            if (!p[1].match(/^[a-f0-9]{64}$/))
+                throw new Error("Zap request 'p' tag is not valid hex.");
+            let e = zapRequest.tags.find(([t, v]) => t === "e" && v);
+            if (e && !e[1].match(/^[a-f0-9]{64}$/))
+                throw new Error("Zap request 'e' tag is not valid hex.");
+            let relays = zapRequest.tags.find(([t, v]) => t === "relays" && v);
+            if (!relays)
+                throw new Error("Zap request doesn't have a 'relays' tag.");
+            return zapRequest;
+        }
+        catch (error) {
+            return undefined;
+        }
+    });
+}
+/**
+ * Checks if a zap event is valid (not missing fields)
+ * DOES NOT validate LNURL address
+ */
+export function isValidZap(zap) {
+    if (!zap)
+        return false;
+    if (zap.kind !== kinds.Zap)
+        return false;
+    // Is not a valid zap kind if any of these is undefined
+    if (getZapPayment(zap) === undefined)
+        return false;
+    if (getZapRequest(zap) === undefined)
+        return false;
+    if (getZapRecipient(zap) === undefined)
+        return false;
+    if (getZapSender(zap) === undefined)
+        return false;
+    return true;
+}
+/** Returns the zap splits for an event */
+export function getZapSplits(event) {
+    const tags = event.tags.filter((t) => t[0] === "zap" && t[1] && t[3]);
+    if (tags.length > 0) {
+        const targets = tags
+            .map((t) => ({ pubkey: t[1], relay: t[2], weight: parseFloat(t[3]) }))
+            .filter((p) => Number.isFinite(p.weight));
+        const total = targets.reduce((v, p) => v + p.weight, 0);
+        return targets.map((p) => ({ ...p, percent: p.weight / total }));
+    }
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as Helpers from "./helpers/index.js";
+export * as Models from "./models/index.js";
+export * as Operations from "./operations/index.js";
+export * as Blueprints from "./blueprints/index.js";
+import "./register.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * as Helpers from "./helpers/index.js";
+export * as Models from "./models/index.js";
+export * as Operations from "./operations/index.js";
+export * as Blueprints from "./blueprints/index.js";
+// Register the common models and blueprints with the event store and event factory
+import "./register.js";

package/dist/models/blossom.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "applesauce-core/event-store";
+import { ProfilePointer } from "applesauce-core/helpers/pointers";
+import { type Observable } from "rxjs";
+/** A model that returns a users blossom servers */
+export declare function UserBlossomServersModel(user: string | ProfilePointer): Model<URL[]>;
+declare module "applesauce-core/event-store" {
+    interface EventModels {
+        /** Subscribe to a users blossom servers */
+        blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+    }
+}

package/dist/models/blossom.js

@@ -0,0 +1,18 @@
+import { map } from "rxjs/operators";
+import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
+// Import EventModels as a value (class) to modify its prototype
+import { EventModels } from "applesauce-core/event-store";
+/** A model that returns a users blossom servers */
+export function UserBlossomServersModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (store) => store
+        .replaceable({ kind: BLOSSOM_SERVER_LIST_KIND, pubkey: user.pubkey, relays: user.relays })
+        .pipe(map((event) => (event ? getBlossomServersFromList(event) : [])));
+}
+// Register this model with EventModels
+EventModels.prototype.blossomServers = function (user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return this.model(UserBlossomServersModel, user);
+};

package/dist/models/bookmarks.d.ts

@@ -0,0 +1,8 @@
+import { Model } from "applesauce-core/event-store";
+import { Bookmarks } from "../helpers/bookmark.js";
+/** A model that returns all the bookmarks of a user */
+export declare function UserBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
+/** A model that returns all the public bookmarks of a user */
+export declare function UserPublicBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
+/** A model that returns all the hidden bookmarks of a user */
+export declare function UserHiddenBookmarkModel(pubkey: string): Model<Bookmarks | null | undefined>;

package/dist/models/bookmarks.js

@@ -0,0 +1,24 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { watchEventUpdates } from "applesauce-core/observable";
+import { map } from "rxjs/operators";
+import { getBookmarks, getHiddenBookmarks, getPublicBookmarks } from "../helpers/bookmark.js";
+/** A model that returns all the bookmarks of a user */
+export function UserBookmarkModel(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    watchEventUpdates(events), 
+    // Get all bookmarks
+    map((event) => event && getBookmarks(event)));
+}
+/** A model that returns all the public bookmarks of a user */
+export function UserPublicBookmarkModel(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicBookmarks(event)));
+}
+/** A model that returns all the hidden bookmarks of a user */
+export function UserHiddenBookmarkModel(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    watchEventUpdates(events), 
+    // Get hidden bookmarks
+    map((event) => event && (getHiddenBookmarks(event) ?? null)));
+}

package/dist/models/calendar.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+/** A model that gets all the events for a calendar */
+export declare function CalendarEventsModel(calendar: NostrEvent): Model<NostrEvent[]>;
+/** A model that gets all the RSVPs for a calendar event */
+export declare function CalendarEventRSVPsModel(event: NostrEvent): Model<NostrEvent[]>;

package/dist/models/calendar.js

@@ -0,0 +1,15 @@
+import { getReplaceableAddress } from "applesauce-core/helpers/event";
+import { defined } from "applesauce-core/observable";
+import { combineLatest } from "rxjs";
+import { CALENDAR_EVENT_RSVP_KIND } from "../helpers/calendar-rsvp.js";
+import { getCalendarAddressPointers } from "../helpers/calendar.js";
+/** A model that gets all the events for a calendar */
+export function CalendarEventsModel(calendar) {
+    return (events) => combineLatest(getCalendarAddressPointers(calendar).map((p) => events.replaceable(p.kind, p.pubkey, p.identifier).pipe(defined())));
+}
+/** A model that gets all the RSVPs for a calendar event */
+export function CalendarEventRSVPsModel(event) {
+    return (events) => {
+        return events.timeline({ kinds: [CALENDAR_EVENT_RSVP_KIND], "#a": [getReplaceableAddress(event)] });
+    };
+}

package/dist/models/channels.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "applesauce-core/event-store";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { ChannelMetadataContent } from "../helpers/channels.js";
+/** A model that returns a map of hidden messages Map<id, reason> */
+export declare function ChannelHiddenModel(channel: NostrEvent, authors?: string[]): Model<Map<string, string>>;
+/** A model that returns all messages in a channel */
+export declare function ChannelMessagesModel(channel: NostrEvent): Model<NostrEvent[]>;
+/** A model that returns the latest parsed metadata */
+export declare function ChannelMetadataModel(channel: NostrEvent): Model<ChannelMetadataContent | undefined>;
+/** A model that returns a map of muted users Map<pubkey, reason> */
+export declare function ChannelMutedModel(channel: NostrEvent, authors?: string[]): Model<Map<string, string>>;