applesauce-core 2.2.0 → 3.0.0

package/dist/helpers/hidden-tags.d.ts

@@ -1,11 +1,12 @@
 import { HiddenContentSigner } from "./hidden-content.js";
+import { EncryptionMethod } from "./encrypted-content.js";
 export declare const HiddenTagsSymbol: unique symbol;
 /** Various event kinds that can have hidden tags */
 export declare const HiddenTagsKinds: Set<number>;
 /** Checks if an event can have hidden tags */
 export declare function canHaveHiddenTags(kind: number): boolean;
 /** Sets the type of encryption to use for hidden tags on a kind */
-export declare function setHiddenTagsEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
+export declare function setHiddenTagsEncryptionMethod(kind: number, method: EncryptionMethod): number;
 /** Checks if an event has hidden tags */
 export declare function hasHiddenTags<T extends {
     kind: number;
@@ -19,25 +20,19 @@ export declare function getHiddenTags<T extends {
 /** Checks if the hidden tags are locked */
 export declare function isHiddenTagsLocked<T extends object>(event: T): boolean;
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-} | {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-};
+export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): import("./encrypted-content.js").EncryptionMethods;
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
- * @param store An optional EventStore to notify about the update
+ * @param override The encryption method to use instead of the default
  * @throws
  */
 export declare function unlockHiddenTags<T extends {
     kind: number;
     pubkey: string;
     content: string;
-}>(event: T, signer: HiddenContentSigner): Promise<string[][]>;
+}>(event: T, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<string[][]>;
 /**
  * Sets the hidden tags on an event and updates it if its part of an event store
  * @throws

package/dist/helpers/hidden-tags.js

@@ -58,15 +58,15 @@ export function getHiddenTagsEncryptionMethods(kind, signer) {
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
- * @param store An optional EventStore to notify about the update
+ * @param override The encryption method to use instead of the default
  * @throws
  */
-export async function unlockHiddenTags(event, signer) {
+export async function unlockHiddenTags(event, signer, override) {
     if (!canHaveHiddenTags(event.kind))
         throw new Error("Event kind does not support hidden tags");
     // unlock hidden content is needed
     if (isHiddenContentLocked(event))
-        await unlockHiddenContent(event, signer);
+        await unlockHiddenContent(event, signer, override);
     return getHiddenTags(event);
 }
 /**

package/dist/helpers/highlight.d.ts

@@ -0,0 +1,45 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export declare const HighlightSourceEventPointerSymbol: unique symbol;
+export declare const HighlightSourceAddressPointerSymbol: unique symbol;
+export declare const HighlightAttributionSymbol: unique symbol;
+/**
+ * Get the highlighted content from a highlight event
+ * Returns the content field which contains the highlighted text
+ */
+export declare function getHighlightText(event: NostrEvent): string;
+/**
+ * Get the source event pointer that was highlighted (from 'e' tag)
+ * Returns undefined if no event reference is found
+ */
+export declare function getHighlightSourceEventPointer(event: NostrEvent): EventPointer | undefined;
+/**
+ * Get the source address pointer that was highlighted (from 'a' tag)
+ * Returns undefined if no address reference is found
+ */
+export declare function getHighlightSourceAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Get the source URL that was highlighted (from 'r' tag) */
+export declare function getHighlightSourceUrl(event: NostrEvent): string | undefined;
+/** Role of an attributed profiles in a highlight */
+export type HighlightAttributionRole = "author" | "editor" | "mention" | string;
+/** Attribution information for a highlight */
+export type HighlightAttribution = ProfilePointer & {
+    /** Role of the attributed profile */
+    role?: HighlightAttributionRole;
+};
+/**
+ * Get attribution information from p tags
+ * Parses p tags to extract authors, editors, and other attributed individuals
+ */
+export declare function getHighlightAttributions(event: NostrEvent): HighlightAttribution[];
+/**
+ * Get the context text for a highlight (from 'context' tag)
+ * This provides surrounding content to give context to the highlight
+ */
+export declare function getHighlightContext(event: NostrEvent): string | undefined;
+/** Get the comment for a highlight (from 'comment' tag) */
+export declare function getHighlightComment(event: NostrEvent): string | undefined;
+/**
+ * Check if the highlight has any source reference (event, address, or URL)
+ */
+export declare function hasHighlightSource(event: NostrEvent): boolean;

package/dist/helpers/highlight.js

@@ -0,0 +1,76 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event-tags.js";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
+import { isATag, isETag, isPTag } from "./tags.js";
+// Symbol constants for caching
+export const HighlightSourceEventPointerSymbol = Symbol.for("highlight-source-event-pointer");
+export const HighlightSourceAddressPointerSymbol = Symbol.for("highlight-source-address-pointer");
+export const HighlightAttributionSymbol = Symbol.for("highlight-attribution");
+/**
+ * Get the highlighted content from a highlight event
+ * Returns the content field which contains the highlighted text
+ */
+export function getHighlightText(event) {
+    return event.content;
+}
+/**
+ * Get the source event pointer that was highlighted (from 'e' tag)
+ * Returns undefined if no event reference is found
+ */
+export function getHighlightSourceEventPointer(event) {
+    return getOrComputeCachedValue(event, HighlightSourceEventPointerSymbol, () => {
+        const eTag = event.tags.find(isETag);
+        return eTag ? getEventPointerFromETag(eTag) : undefined;
+    });
+}
+/**
+ * Get the source address pointer that was highlighted (from 'a' tag)
+ * Returns undefined if no address reference is found
+ */
+export function getHighlightSourceAddressPointer(event) {
+    return getOrComputeCachedValue(event, HighlightSourceAddressPointerSymbol, () => {
+        const aTag = event.tags.find(isATag);
+        return aTag ? getAddressPointerFromATag(aTag) : undefined;
+    });
+}
+/** Get the source URL that was highlighted (from 'r' tag) */
+export function getHighlightSourceUrl(event) {
+    return getTagValue(event, "r");
+}
+/**
+ * Get attribution information from p tags
+ * Parses p tags to extract authors, editors, and other attributed individuals
+ */
+export function getHighlightAttributions(event) {
+    return getOrComputeCachedValue(event, HighlightAttributionSymbol, () => {
+        const attributions = [];
+        const pTags = event.tags.filter(isPTag);
+        for (const pTag of pTags) {
+            const pointer = getProfilePointerFromPTag(pTag);
+            const role = pTag[3] || "other"; // Role is the 4th element (index 3)
+            const entry = { ...pointer, role };
+            // Categorize by role
+            attributions.push(entry);
+        }
+        return attributions;
+    });
+}
+/**
+ * Get the context text for a highlight (from 'context' tag)
+ * This provides surrounding content to give context to the highlight
+ */
+export function getHighlightContext(event) {
+    return getTagValue(event, "context");
+}
+/** Get the comment for a highlight (from 'comment' tag) */
+export function getHighlightComment(event) {
+    return getTagValue(event, "comment");
+}
+/**
+ * Check if the highlight has any source reference (event, address, or URL)
+ */
+export function hasHighlightSource(event) {
+    return !!(getHighlightSourceEventPointer(event) ||
+        getHighlightSourceAddressPointer(event) ||
+        getHighlightSourceUrl(event));
+}

package/dist/helpers/index.d.ts

@@ -4,6 +4,9 @@ export * from "./blossom.js";
 export * from "./bolt11.js";
 export * from "./bookmarks.js";
 export * from "./cache.js";
+export * from "./calendar-event.js";
+export * from "./calendar-rsvp.js";
+export * from "./calendar.js";
 export * from "./channels.js";
 export * from "./comment.js";
 export * from "./contacts.js";
@@ -14,6 +17,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-cache.js";
 export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";
@@ -25,6 +29,7 @@ export * from "./groups.js";
 export * from "./hashtag.js";
 export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
+export * from "./highlight.js";
 export * from "./json.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
@@ -35,11 +40,14 @@ export * from "./messages.js";
 export * from "./mutes.js";
 export * from "./picture-post.js";
 export * from "./pointers.js";
+export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";
+export * from "./stream-chat.js";
+export * from "./stream.js";
 export * from "./string.js";
 export * from "./tags.js";
 export * from "./threading.js";

package/dist/helpers/index.js

@@ -4,6 +4,9 @@ export * from "./blossom.js";
 export * from "./bolt11.js";
 export * from "./bookmarks.js";
 export * from "./cache.js";
+export * from "./calendar-event.js";
+export * from "./calendar-rsvp.js";
+export * from "./calendar.js";
 export * from "./channels.js";
 export * from "./comment.js";
 export * from "./contacts.js";
@@ -14,6 +17,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-cache.js";
 export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";
@@ -25,6 +29,7 @@ export * from "./groups.js";
 export * from "./hashtag.js";
 export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
+export * from "./highlight.js";
 export * from "./json.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
@@ -35,11 +40,14 @@ export * from "./messages.js";
 export * from "./mutes.js";
 export * from "./picture-post.js";
 export * from "./pointers.js";
+export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";
+export * from "./stream-chat.js";
+export * from "./stream.js";
 export * from "./string.js";
 export * from "./tags.js";
 export * from "./threading.js";

package/dist/helpers/pointers.js

@@ -187,7 +187,7 @@ export function addRelayHintsToPointer(pointer, relays) {
 /** Gets the hex pubkey from any nip-19 encoded string */
 export function normalizeToPubkey(str) {
     if (isHexKey(str))
-        return str;
+        return str.toLowerCase();
     else {
         const decode = nip19.decode(str);
         const pubkey = getPubkeyFromDecodeResult(decode);

package/dist/helpers/poll.d.ts

@@ -0,0 +1,46 @@
+import { NostrEvent } from "nostr-tools";
+export declare const POLL_KIND = 1068;
+export declare const POLL_RESPONSE_KIND = 1018;
+export declare const PollOptionsSymbol: unique symbol;
+export interface PollOption {
+    id: string;
+    label: string;
+}
+export type PollType = "singlechoice" | "multiplechoice";
+/**
+ * Get the poll question/label from a poll event
+ * Returns the content field which contains the poll question
+ */
+export declare function getPollQuestion(event: NostrEvent): string;
+/**
+ * Get the poll options from a poll event
+ * Returns array of options with id and label
+ */
+export declare function getPollOptions(event: NostrEvent): PollOption[];
+/**
+ * Get the relays specified for poll responses (from 'relay' tags)
+ * Returns undefined if no relays are specified
+ */
+export declare function getPollRelays(event: NostrEvent): string[];
+/**
+ * Get the poll type from a poll event (from 'polltype' tag)
+ * Returns "singlechoice" or "multiplechoice", defaults to "singlechoice"
+ */
+export declare function getPollType(event: NostrEvent): PollType;
+/**
+ * Get the poll expiration timestamp (from 'endsAt' tag)
+ * Returns undefined if no expiration is set
+ */
+export declare function getPollEndsAt(event: NostrEvent): number | undefined;
+/**
+ * Get the poll ID that a response is referencing (from 'e' tag)
+ * Returns undefined if no poll reference is found
+ */
+export declare function getPollResponsePollId(event: NostrEvent): string | undefined;
+/** Get the selected option IDs from a poll response event (from 'response' tags) */
+export declare function getPollResponseOptions(event: NostrEvent): string[];
+/**
+ * Gets the options that a user has voted for in a poll event
+ * Returns undefined if the response is not valid
+ */
+export declare function getPollResponseVotes(poll: NostrEvent, response: NostrEvent): string[] | undefined;

package/dist/helpers/poll.js

@@ -0,0 +1,78 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event-tags.js";
+// NIP-88 Poll kinds
+export const POLL_KIND = 1068;
+export const POLL_RESPONSE_KIND = 1018;
+// Cache symbols
+export const PollOptionsSymbol = Symbol.for("poll-options");
+/**
+ * Get the poll question/label from a poll event
+ * Returns the content field which contains the poll question
+ */
+export function getPollQuestion(event) {
+    return event.content;
+}
+/**
+ * Get the poll options from a poll event
+ * Returns array of options with id and label
+ */
+export function getPollOptions(event) {
+    return getOrComputeCachedValue(event, PollOptionsSymbol, () => {
+        return event.tags
+            .filter((tag) => tag[0] === "option" && tag.length >= 3)
+            .map((tag) => ({
+            id: tag[1],
+            label: tag[2],
+        }));
+    });
+}
+/**
+ * Get the relays specified for poll responses (from 'relay' tags)
+ * Returns undefined if no relays are specified
+ */
+export function getPollRelays(event) {
+    return event.tags.filter((tag) => tag[0] === "relay" && tag.length >= 2).map((tag) => tag[1]);
+}
+/**
+ * Get the poll type from a poll event (from 'polltype' tag)
+ * Returns "singlechoice" or "multiplechoice", defaults to "singlechoice"
+ */
+export function getPollType(event) {
+    const type = getTagValue(event, "polltype");
+    return type === "multiplechoice" || type === "singlechoice" ? type : "singlechoice";
+}
+/**
+ * Get the poll expiration timestamp (from 'endsAt' tag)
+ * Returns undefined if no expiration is set
+ */
+export function getPollEndsAt(event) {
+    const endsAt = getTagValue(event, "endsAt");
+    return endsAt ? parseInt(endsAt, 10) : undefined;
+}
+/**
+ * Get the poll ID that a response is referencing (from 'e' tag)
+ * Returns undefined if no poll reference is found
+ */
+export function getPollResponsePollId(event) {
+    return getTagValue(event, "e");
+}
+/** Get the selected option IDs from a poll response event (from 'response' tags) */
+export function getPollResponseOptions(event) {
+    return event.tags.filter((tag) => tag[0] === "response" && tag.length >= 2).map((tag) => tag[1]);
+}
+/**
+ * Gets the options that a user has voted for in a poll event
+ * Returns undefined if the response is not valid
+ */
+export function getPollResponseVotes(poll, response) {
+    if (poll.id !== getPollResponsePollId(response))
+        return;
+    const pollOptions = getPollOptions(poll);
+    const responseOptions = getPollResponseOptions(response);
+    const votes = responseOptions.filter((opts) => pollOptions.some((option) => option.id === opts));
+    const type = getPollType(poll);
+    // If its a single choice poll, return the first vote
+    if (type === "singlechoice")
+        return votes.length === 1 ? [votes[0]] : undefined;
+    return Array.from(new Set(votes));
+}

package/dist/helpers/stream-chat.d.ts

@@ -0,0 +1,4 @@
+import { AddressPointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+/** Returns the pointer to the stream chat message stream */
+export declare function getStreamChatMessageStream(message: NostrEvent): AddressPointer | undefined;

package/dist/helpers/stream-chat.js

@@ -0,0 +1,9 @@
+import { getAddressPointerFromATag } from "./pointers.js";
+import { isATag } from "./tags.js";
+/** Returns the pointer to the stream chat message stream */
+export function getStreamChatMessageStream(message) {
+    const tag = message.tags.find(isATag);
+    if (!tag)
+        return undefined;
+    return getAddressPointerFromATag(tag);
+}

package/dist/helpers/stream.d.ts

@@ -0,0 +1,31 @@
+import { NostrEvent } from "nostr-tools";
+import { EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export type StreamStatus = "live" | "ended" | "planned";
+export type StreamRole = "host" | "participant" | "speaker";
+export declare function getStreamTitle(stream: NostrEvent): string | undefined;
+export declare function getStreamSummary(stream: NostrEvent): string | undefined;
+export declare function getStreamImage(stream: NostrEvent): string | undefined;
+/** Returns the status of the stream, defaults to ended if the stream is older than 2 weeks */
+export declare function getStreamStatus(stream: NostrEvent): StreamStatus;
+/** Returns the pubkey of the host of the stream */
+export declare function getStreamHost(stream: NostrEvent): ProfilePointer;
+/** Returns the participants of a stream */
+export declare function getStreamParticipants(stream: NostrEvent): (ProfilePointer & {
+    role: StreamRole;
+})[];
+export declare function getStreamGoalPointer(stream: NostrEvent): EventPointer | undefined;
+/** Gets all the streaming urls for a stream */
+export declare function getStreamStreamingURLs(stream: NostrEvent): string[];
+export declare function getStreamRecording(stream: NostrEvent): string | undefined;
+/** Gets the relays for a stream */
+export declare function getStreamRelays(stream: NostrEvent): string[] | undefined;
+/** Gets the stream start time if it has one */
+export declare function getStreamStartTime(stream: NostrEvent): number | undefined;
+/** Gets the stream end time if it has one */
+export declare function getStreamEndTime(stream: NostrEvent): number | undefined;
+/** Returns the current number of participants in the stream */
+export declare function getStreamViewers(stream: NostrEvent): number | undefined;
+/** Returns the maximum number of participants in the stream */
+export declare function getStreamMaxViewers(stream: NostrEvent): number | undefined;
+/** Returns the hashtags for a stream */
+export declare function getStreamHashtags(stream: NostrEvent): string[];

package/dist/helpers/stream.js

@@ -0,0 +1,81 @@
+import { getTagValue } from "./event-tags.js";
+import { addRelayHintsToPointer, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
+import { mergeRelaySets } from "./relays.js";
+import { isPTag } from "./tags.js";
+import { unixNow } from "./time.js";
+export function getStreamTitle(stream) {
+    return getTagValue(stream, "title");
+}
+export function getStreamSummary(stream) {
+    return getTagValue(stream, "summary");
+}
+export function getStreamImage(stream) {
+    return getTagValue(stream, "image");
+}
+const TWO_WEEKS = 60 * 60 * 24 * 14;
+/** Returns the status of the stream, defaults to ended if the stream is older than 2 weeks */
+export function getStreamStatus(stream) {
+    if (stream.created_at < unixNow() - TWO_WEEKS)
+        return "ended";
+    else
+        return getTagValue(stream, "status") || "ended";
+}
+/** Returns the pubkey of the host of the stream */
+export function getStreamHost(stream) {
+    let host = undefined;
+    for (const tag of stream.tags) {
+        if (isPTag(tag) && (!host || (tag[3] && tag[3].toLowerCase() === "host"))) {
+            host = getProfilePointerFromPTag(tag);
+        }
+    }
+    return host || { pubkey: stream.pubkey };
+}
+/** Returns the participants of a stream */
+export function getStreamParticipants(stream) {
+    return stream.tags
+        .filter((t) => isPTag(t) && t[3])
+        .map((t) => ({ ...getProfilePointerFromPTag(t), role: t[3].toLowerCase() }));
+}
+export function getStreamGoalPointer(stream) {
+    const goalTag = stream.tags.find((t) => t[0] === "goal");
+    return goalTag && addRelayHintsToPointer(getEventPointerFromETag(goalTag), getStreamRelays(stream));
+}
+/** Gets all the streaming urls for a stream */
+export function getStreamStreamingURLs(stream) {
+    return stream.tags.filter((t) => t[0] === "streaming").map((t) => t[1]);
+}
+export function getStreamRecording(stream) {
+    return getTagValue(stream, "recording");
+}
+/** Gets the relays for a stream */
+export function getStreamRelays(stream) {
+    for (const tag of stream.tags) {
+        if (tag[0] === "relays")
+            return mergeRelaySets(tag.slice(1));
+    }
+    return undefined;
+}
+/** Gets the stream start time if it has one */
+export function getStreamStartTime(stream) {
+    const str = getTagValue(stream, "starts");
+    return str ? parseInt(str) : undefined;
+}
+/** Gets the stream end time if it has one */
+export function getStreamEndTime(stream) {
+    const str = getTagValue(stream, "ends");
+    return str ? parseInt(str) : getStreamStatus(stream) === "ended" ? stream.created_at : undefined;
+}
+/** Returns the current number of participants in the stream */
+export function getStreamViewers(stream) {
+    const viewers = getTagValue(stream, "current_participants");
+    return viewers ? parseInt(viewers) : undefined;
+}
+/** Returns the maximum number of participants in the stream */
+export function getStreamMaxViewers(stream) {
+    const viewers = getTagValue(stream, "total_participants");
+    return viewers ? parseInt(viewers) : undefined;
+}
+/** Returns the hashtags for a stream */
+export function getStreamHashtags(stream) {
+    return stream.tags.filter((t) => t[0] === "t").map((t) => t[1]);
+}

package/dist/logger.d.ts

@@ -1,2 +1,3 @@
 import debug from "debug";
+/** @hidden */
 export declare const logger: debug.Debugger;

package/dist/logger.js

@@ -1,2 +1,3 @@
 import debug from "debug";
+/** @hidden */
 export const logger = debug("applesauce");

package/dist/models/blossom.d.ts

@@ -1,3 +1,4 @@
+import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
 /** A model that returns a users blossom servers */
-export declare function UserBlossomServersModel(pubkey: string): Model<URL[]>;
+export declare function UserBlossomServersModel(user: string | ProfilePointer): Model<URL[]>;

package/dist/models/blossom.js

@@ -1,8 +1,10 @@
 import { map } from "rxjs/operators";
 import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
 /** A model that returns a users blossom servers */
-export function UserBlossomServersModel(pubkey) {
+export function UserBlossomServersModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
     return (store) => store
-        .replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey)
+        .replaceable({ kind: BLOSSOM_SERVER_LIST_KIND, pubkey: user.pubkey, relays: user.relays })
         .pipe(map((event) => (event ? getBlossomServersFromList(event) : [])));
 }

package/dist/models/calendar.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+/** 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 { combineLatest } from "rxjs";
+import { CALENDAR_EVENT_RSVP_KIND } from "../helpers/calendar-rsvp.js";
+import { getCalendarAddressPointers } from "../helpers/calendar.js";
+import { getReplaceableAddress } from "../helpers/index.js";
+import { defined } from "../observable/defined.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/common.d.ts

@@ -1,16 +1,20 @@
 import { Filter, NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
+import { AddressPointerWithoutD } from "../helpers/index.js";
 /** A model that returns a single event or undefined when its removed */
-export declare function EventModel(id: string): Model<NostrEvent | undefined>;
+export declare function EventModel(pointer: string | EventPointer): Model<NostrEvent | undefined>;
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
-export declare function ReplaceableModel(kind: number, pubkey: string, d?: string): Model<NostrEvent | undefined>;
+export declare function ReplaceableModel(pointer: AddressPointer | AddressPointerWithoutD): Model<NostrEvent | undefined>;
 /** A model that returns an array of sorted events matching the filters */
 export declare function TimelineModel(filters: Filter | Filter[], includeOldVersion?: boolean): Model<NostrEvent[]>;
-/** A model that returns a multiple events in a map */
-export declare function EventsModel(ids: string[]): Model<Record<string, NostrEvent>>;
-/** A model that returns a directory of events by their UID */
-export declare function ReplaceableSetModel(pointers: {
-    kind: number;
-    pubkey: string;
-    identifier?: string;
-}[]): Model<Record<string, NostrEvent>>;
+/**
+ * A model that returns a multiple events in a map
+ * @deprecated use multiple {@link EventModel} instead
+ */
+export declare function EventsModel(ids: string[]): Model<Record<string, NostrEvent | undefined>>;
+/**
+ * A model that returns a directory of events by their UID
+ * @deprecated use multiple {@link ReplaceableModel} instead
+ */
+export declare function ReplaceableSetModel(pointers: (AddressPointer | AddressPointerWithoutD)[]): Model<Record<string, NostrEvent | undefined>>;