applesauce-core 1.2.0 → 2.0.0

package/dist/{queries → models}/mailboxes.js

@@ -1,8 +1,8 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
-/** A query that gets and parses the inbox and outbox relays for a pubkey */
-export function MailboxesQuery(pubkey) {
+/** A model that gets and parses the inbox and outbox relays for a pubkey */
+export function MailboxesModel(pubkey) {
     return (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
         inboxes: getInboxes(event),
         outboxes: getOutboxes(event),

package/dist/models/mutes.d.ts

@@ -0,0 +1,8 @@
+import { Mutes } from "../helpers/mutes.js";
+import { Model } from "../event-store/interface.js";
+/** A model that returns all a users muted things */
+export declare function MuteModel(pubkey: string): 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>;

package/dist/{queries → models}/mutes.js

@@ -1,24 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { getHiddenMutedThings, getMutedThings, getPublicMutedThings } from "../helpers/mutes.js";
-import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
-/** A query that returns all a users muted things */
-export function MuteQuery(pubkey) {
+import { watchEventUpdates } from "../observable/watch-event-updates.js";
+/** A model that returns all a users muted things */
+export function MuteModel(pubkey) {
     return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
     // listen for event updates (hidden tags unlocked)
-    listenLatestUpdates(events), 
+    watchEventUpdates(events), 
     // Get all muted things
     map((event) => event && getMutedThings(event)));
 }
-/** A query that returns all a users public muted things */
-export function PublicMuteQuery(pubkey) {
+/** 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 query that returns all a users hidden muted things */
-export function HiddenMuteQuery(pubkey) {
+/** 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)
-    listenLatestUpdates(events), 
+    watchEventUpdates(events), 
     // Get hidden muted things
     map((event) => event && getHiddenMutedThings(event)));
 }

package/dist/models/pins.d.ts

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

package/dist/{queries → models}/pins.js

@@ -1,9 +1,9 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { isETag, processTags } from "../helpers/tags.js";
 import { getEventPointerFromETag } from "../helpers/pointers.js";
-/** A query that returns all pinned pointers for a user */
-export function UserPinnedQuery(pubkey) {
+import { isETag, processTags } from "../helpers/tags.js";
+/** 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/profile.d.ts

@@ -0,0 +1,4 @@
+import { Model } from "../event-store/interface.js";
+import { ProfileContent } from "../helpers/profile.js";
+/** A model that gets and parses the kind 0 metadata for a pubkey */
+export declare function ProfileModel(pubkey: string): Model<ProfileContent | undefined>;

package/dist/models/profile.js

@@ -0,0 +1,14 @@
+import { kinds } from "nostr-tools";
+import { filter, map } from "rxjs/operators";
+import { getProfileContent, isValidProfile } from "../helpers/profile.js";
+import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
+/** A model that gets and parses the kind 0 metadata for a pubkey */
+export function ProfileModel(pubkey) {
+    return (events) => events.replaceable(kinds.Metadata, pubkey).pipe(
+    // Filter out invalid profile events
+    filter(isValidProfile), 
+    // Parse the profile event into a ProfileContent
+    map((event) => event && getProfileContent(event)), 
+    // Ensure the model is synchronous
+    withImmediateValueOrDefault(undefined));
+}

package/dist/models/reactions.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+/** A model that returns all reactions to an event (supports replaceable events) */
+export declare function ReactionsModel(event: NostrEvent): Model<NostrEvent[]>;

package/dist/{queries → models}/reactions.js

@@ -1,7 +1,7 @@
 import { kinds } from "nostr-tools";
 import { getEventUID, isReplaceable } from "../helpers/event.js";
-/** A query that returns all reactions to an event (supports replaceable events) */
-export function ReactionsQuery(event) {
+/** 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] },

package/dist/models/relays.d.ts

@@ -0,0 +1,27 @@
+import { AddressPointer } from "nostr-tools/nip19";
+import { ReadListTags } from "../helpers/lists.js";
+import { Model } from "../event-store/interface.js";
+/**
+ * A model that returns all favorite relays for a pubkey
+ * @param pubkey - The pubkey to get the favorite relays for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelaysModel(pubkey: string, type?: ReadListTags): Model<string[] | undefined>;
+/**
+ * A model that returns all favorite relay sets for a pubkey
+ * @param pubkey - The pubkey to get the favorite relay sets for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelaySetsModel(pubkey: string, type?: ReadListTags): Model<AddressPointer[] | undefined>;
+/**
+ * A model that returns all search relays for a pubkey
+ * @param pubkey - The pubkey to get the search relays for
+ * @param type - Which types of tags to read
+ */
+export declare function SearchRelaysModel(pubkey: string, type?: ReadListTags): Model<string[] | undefined>;
+/**
+ * A model that returns all blocked relays for a pubkey
+ * @param pubkey - The pubkey to get the blocked relays for
+ * @param type - Which types of tags to read
+ */
+export declare function BlockedRelaysModel(pubkey: string, type?: ReadListTags): Model<string[] | undefined>;

package/dist/{queries → models}/relays.js

@@ -1,44 +1,44 @@
 import { kinds } from "nostr-tools";
 import { identity, map } from "rxjs";
 import { FAVORITE_RELAYS_KIND, getAddressPointersFromList, getRelaysFromList } from "../helpers/lists.js";
-import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
+import { watchEventUpdates } from "../observable/watch-event-updates.js";
 /**
- * A query that returns all favorite relays for a pubkey
+ * A model that returns all favorite relays for a pubkey
  * @param pubkey - The pubkey to get the favorite relays for
  * @param type - Which types of tags to read
  */
-export function FavoriteRelays(pubkey, type) {
+export function FavoriteRelaysModel(pubkey, type) {
     return (events) => {
-        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? watchEventUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
     };
 }
 /**
- * A query that returns all favorite relay sets for a pubkey
+ * A model that returns all favorite relay sets for a pubkey
  * @param pubkey - The pubkey to get the favorite relay sets for
  * @param type - Which types of tags to read
  */
-export function FavoriteRelaySets(pubkey, type) {
+export function FavoriteRelaySetsModel(pubkey, type) {
     return (events) => {
-        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getAddressPointersFromList(e, type)));
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? watchEventUpdates(events) : map(identity), map((e) => e && getAddressPointersFromList(e, type)));
     };
 }
 /**
- * A query that returns all search relays for a pubkey
+ * A model that returns all search relays for a pubkey
  * @param pubkey - The pubkey to get the search relays for
  * @param type - Which types of tags to read
  */
-export function SearchRelays(pubkey, type) {
+export function SearchRelaysModel(pubkey, type) {
     return (events) => {
-        return events.replaceable(kinds.SearchRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+        return events.replaceable(kinds.SearchRelaysList, pubkey).pipe(type !== "public" ? watchEventUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
     };
 }
 /**
- * A query that returns all blocked relays for a pubkey
+ * A model that returns all blocked relays for a pubkey
  * @param pubkey - The pubkey to get the blocked relays for
  * @param type - Which types of tags to read
  */
-export function BlockedRelays(pubkey, type) {
+export function BlockedRelaysModel(pubkey, type) {
     return (events) => {
-        return events.replaceable(kinds.BlockedRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+        return events.replaceable(kinds.BlockedRelaysList, pubkey).pipe(type !== "public" ? watchEventUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
     };
 }

package/dist/{queries → models}/thread.d.ts

@@ -1,7 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
-import { Query } from "../query-store/index.js";
 import { ThreadReferences } from "../helpers/threading.js";
+import { Model } from "../event-store/interface.js";
 export type Thread = {
     root?: ThreadItem;
     all: Map<string, ThreadItem>;
@@ -17,9 +17,10 @@ export type ThreadItem = {
     /** direct child replies */
     replies: Set<ThreadItem>;
 };
-export type ThreadQueryOptions = {
+export type ThreadModelOptions = {
     kinds?: number[];
 };
-export declare function ThreadQuery(root: string | AddressPointer | EventPointer, opts?: ThreadQueryOptions): Query<Thread>;
-/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
-export declare function RepliesQuery(event: NostrEvent, overrideKinds?: number[]): Query<NostrEvent[]>;
+/** 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[]>;

package/dist/{queries → models}/thread.js

@@ -8,7 +8,8 @@ import { COMMENT_KIND } from "../helpers/comment.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
 };
-export function ThreadQuery(root, opts) {
+/** 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 };
@@ -63,8 +64,8 @@ export function ThreadQuery(root, opts) {
         return { root: items.get(rootUID), all: items };
     }));
 }
-/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
-export function RepliesQuery(event, overrideKinds) {
+/** 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 };

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

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+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/{queries → models}/user-status.js

@@ -1,9 +1,9 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs";
-import { getUserStatusPointer } from "../helpers/user-status.js";
 import { getReplaceableIdentifier } from "../helpers/event.js";
-/** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
-export function UserStatusQuery(pubkey, type = "general") {
+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;
@@ -17,8 +17,8 @@ export function UserStatusQuery(pubkey, type = "general") {
         };
     }));
 }
-/** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
-export function UserStatusesQuery(pubkey) {
+/** 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 {

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

@@ -0,0 +1,25 @@
+import { Model } from "../event-store/interface.js";
+import { Rumor } from "../helpers/gift-wraps.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 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 WrappedMessagesConversation(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 conversation - The conversation identifier
+ */
+export declare function WrappedMessageThreads(self: string, conversation: 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,61 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs";
+import { getGiftWrapRumor } from "../helpers/gift-wraps.js";
+import { createConversationIdentifier, getConversationIdentifierFromMessage, getConversationParticipants, getWrappedMessageParent, } from "../helpers/wrapped-messages.js";
+import { watchEventsUpdates } from "../observable/watch-event-updates.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)
+        .sort((a, b) => b.created_at - a.created_at)));
+}
+/**
+ * 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 WrappedMessagesConversation(self, participants) {
+    // Get the conversation identifier include the users pubkey
+    const identifier = createConversationIdentifier([
+        self,
+        ...(typeof participants === "string" ? getConversationParticipants(participants) : 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 conversation - The conversation identifier
+ */
+export function WrappedMessageThreads(self, conversation) {
+    return (store) => store.model(WrappedMessagesConversation, self, conversation).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(WrappedMessagesConversation, 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 { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { Model } from "../event-store/interface.js";
+/** A model that gets all zap events for an event */
+export declare function EventZapsModel(id: string | EventPointer | AddressPointer): Model<NostrEvent[]>;
+/** A model that returns all zaps sent by a user */
+export declare function SentZapsModel(pubkey: string): Model<NostrEvent[]>;
+/** A model that returns all zaps received by a user */
+export declare function ReceivedZapsModel(pubkey: string): Model<NostrEvent[]>;

package/dist/{queries → models}/zaps.js

@@ -1,9 +1,9 @@
-import { map } from "rxjs";
 import { kinds } from "nostr-tools";
+import { map } from "rxjs";
 import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
 import { isValidZap } from "../helpers/zap.js";
-/** A query that gets all zap events for an event */
-export function EventZapsQuery(id) {
+/** A model that gets all zap events for an event */
+export function EventZapsModel(id) {
     return (events) => {
         if (isAddressPointer(id)) {
             return events
@@ -16,3 +16,11 @@ export function EventZapsQuery(id) {
         }
     };
 }
+/** A model that returns all zaps sent by a user */
+export function SentZapsModel(pubkey) {
+    return (events) => events.timeline([{ kinds: [kinds.Zap], authors: [pubkey] }]);
+}
+/** A model that returns all zaps received by a user */
+export function ReceivedZapsModel(pubkey) {
+    return (events) => events.timeline([{ kinds: [kinds.Zap], "#a": [pubkey] }]);
+}

package/dist/observable/claim-events.d.ts

@@ -1,5 +1,5 @@
-import { MonoTypeOperatorFunction } from "rxjs";
 import { NostrEvent } from "nostr-tools";
-import { Database } from "../event-store/database.js";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IEventClaims } from "../event-store/interface.js";
 /** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
-export declare function claimEvents<T extends NostrEvent[] | NostrEvent | undefined>(database: Database): MonoTypeOperatorFunction<T>;
+export declare function claimEvents<T extends NostrEvent[] | NostrEvent | undefined>(claims: IEventClaims): MonoTypeOperatorFunction<T>;

package/dist/observable/claim-events.js

@@ -1,6 +1,6 @@
 import { finalize, tap } from "rxjs";
 /** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
-export function claimEvents(database) {
+export function claimEvents(claims) {
     return (source) => {
         const seen = new Set();
         return source.pipe(
@@ -11,18 +11,18 @@ export function claimEvents(database) {
             if (Array.isArray(message)) {
                 for (const event of message) {
                     seen.add(event);
-                    database.claimEvent(event, source);
+                    claims.claim(event, source);
                 }
             }
             else {
                 seen.add(message);
-                database.claimEvent(message, source);
+                claims.claim(message, source);
             }
         }), 
         // remove claims on cleanup
         finalize(() => {
             for (const e of seen)
-                database.removeClaim(e, source);
+                claims.removeClaim(e, source);
         }));
     };
 }

package/dist/observable/claim-latest.d.ts

@@ -1,5 +1,5 @@
-import { MonoTypeOperatorFunction } from "rxjs";
 import { NostrEvent } from "nostr-tools";
-import { type Database } from "../event-store/database.js";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IEventClaims } from "../event-store/interface.js";
 /** An operator that claims the latest event with the database */
-export declare function claimLatest<T extends NostrEvent | undefined>(database: Database): MonoTypeOperatorFunction<T>;
+export declare function claimLatest<T extends NostrEvent | undefined>(claims: IEventClaims): MonoTypeOperatorFunction<T>;

package/dist/observable/claim-latest.js

@@ -1,21 +1,21 @@
 import { finalize, tap } from "rxjs";
 /** An operator that claims the latest event with the database */
-export function claimLatest(database) {
+export function claimLatest(claims) {
     return (source) => {
         let latest = undefined;
         return source.pipe(tap((event) => {
             // remove old claim
             if (latest)
-                database.removeClaim(latest, source);
+                claims.removeClaim(latest, source);
             // claim new event
             if (event)
-                database.claimEvent(event, source);
+                claims.claim(event, source);
             // update state
             latest = event;
         }), finalize(() => {
             // remove latest claim
             if (latest)
-                database.removeClaim(latest, source);
+                claims.removeClaim(latest, source);
         }));
     };
 }

package/dist/observable/index.d.ts

@@ -1,7 +1,9 @@
 import { firstValueFrom, lastValueFrom } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./listen-latest-updates.js";
+export * from "./map-events-timeline.js";
+export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
+export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
 export { firstValueFrom, lastValueFrom };

package/dist/observable/index.js

@@ -1,8 +1,10 @@
 import { firstValueFrom, lastValueFrom } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./listen-latest-updates.js";
+export * from "./map-events-timeline.js";
+export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
+export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
 // Re-export some useful rxjs functions
 export { firstValueFrom, lastValueFrom };

package/dist/observable/map-events-timeline.d.ts

@@ -0,0 +1,7 @@
+import { NostrEvent } from "nostr-tools";
+import { OperatorFunction } from "rxjs";
+/**
+ * Accumulate events into an ordered timeline
+ * @note This does not remove duplicate events
+ */
+export declare function mapEventsToTimeline(): OperatorFunction<NostrEvent, NostrEvent[]>;

package/dist/observable/map-events-timeline.js

@@ -0,0 +1,9 @@
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { scan } from "rxjs";
+/**
+ * Accumulate events into an ordered timeline
+ * @note This does not remove duplicate events
+ */
+export function mapEventsToTimeline() {
+    return scan((timeline, event) => insertEventIntoDescendingList(timeline, event), []);
+}

package/dist/observable/map-events-to-store.d.ts

@@ -0,0 +1,5 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+import { NostrEvent } from "nostr-tools";
+import { IEventStore } from "../event-store/interface.js";
+/** Saves all events to an event store and filters out invalid events */
+export declare function mapEventsToStore(store: IEventStore, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;

package/dist/observable/map-events-to-store.js

@@ -0,0 +1,12 @@
+import { distinct, filter, identity, map } from "rxjs";
+/** Saves all events to an event store and filters out invalid events */
+export function mapEventsToStore(store, removeDuplicates = true) {
+    return (source) => source.pipe(
+    // Map all events to the store
+    // NOTE: map is used here because we want to return the single cononical version of the event so that distinct() can be used later
+    map((event) => store.add(event)), 
+    // Ignore invalid events
+    filter((e) => e !== null), 
+    // Remove duplicates if requested
+    removeDuplicates ? distinct() : identity);
+}

package/dist/observable/simple-timeout.d.ts

@@ -1,4 +1,5 @@
 import { MonoTypeOperatorFunction } from "rxjs";
 export declare class TimeoutError extends Error {
 }
+/** Throws a {@link TimeoutError} if a value is not emitted within the timeout */
 export declare function simpleTimeout<T extends unknown>(first: number, message?: string): MonoTypeOperatorFunction<T>;

package/dist/observable/simple-timeout.js

@@ -1,6 +1,7 @@
 import { throwError, timeout } from "rxjs";
 export class TimeoutError extends Error {
 }
+/** Throws a {@link TimeoutError} if a value is not emitted within the timeout */
 export function simpleTimeout(first, message) {
     return timeout({ first, with: () => throwError(() => new TimeoutError(message ?? "Timeout")) });
 }

package/dist/observable/watch-event-updates.d.ts

@@ -0,0 +1,7 @@
+import { NostrEvent } from "nostr-tools";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IEventStoreStreams } from "../event-store/interface.js";
+/** Watches for any updates to the latest event and remits the event when updated */
+export declare function watchEventUpdates(eventStore: IEventStoreStreams): MonoTypeOperatorFunction<NostrEvent | undefined>;
+/** Watches for any updates to the latest array of events and remits the array of events when updated */
+export declare function watchEventsUpdates(eventStore: IEventStoreStreams): MonoTypeOperatorFunction<NostrEvent[]>;

package/dist/observable/watch-event-updates.js

@@ -0,0 +1,25 @@
+import { filter, map, merge, tap } from "rxjs";
+/** Watches for any updates to the latest event and remits the event when updated */
+export function watchEventUpdates(eventStore) {
+    return (source) => {
+        let latest;
+        return merge(
+        // Get the latest event
+        source.pipe(tap((value) => (latest = value))), 
+        // listen for updates
+        eventStore.update$.pipe(filter((e) => e.id === latest?.id)));
+    };
+}
+/** Watches for any updates to the latest array of events and remits the array of events when updated */
+export function watchEventsUpdates(eventStore) {
+    return (source) => {
+        let latest = [];
+        return merge(
+        // Get the latest event
+        source.pipe(tap((value) => (latest = value))), 
+        // listen for updates
+        eventStore.update$.pipe(filter((e) => latest.includes(e)), 
+        // re-emit the array of events
+        map(() => latest)));
+    };
+}