applesauce-core 3.1.0 → 4.1.0

package/dist/models/common.d.ts

@@ -1,13 +1,13 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
-import { Model } from "../event-store/interface.js";
+import { IAsyncEventStore, IEventStore, 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(pointer: string | EventPointer): Model<NostrEvent | undefined>;
+export declare function EventModel(pointer: string | EventPointer): Model<NostrEvent | undefined, IEventStore | IAsyncEventStore>;
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
-export declare function ReplaceableModel(pointer: AddressPointer | AddressPointerWithoutD): Model<NostrEvent | undefined>;
+export declare function ReplaceableModel(pointer: AddressPointer | AddressPointerWithoutD): Model<NostrEvent | undefined, IEventStore | IAsyncEventStore>;
 /** A model that returns an array of sorted events matching the filters */
-export declare function TimelineModel(filters: Filter | Filter[], includeOldVersion?: boolean): Model<NostrEvent[]>;
+export declare function TimelineModel(filters: Filter | Filter[], includeOldVersion?: boolean): Model<NostrEvent[], IEventStore | IAsyncEventStore>;
 /**
  * A model that returns a multiple events in a map
  * @deprecated use multiple {@link EventModel} instead

package/dist/models/common.js

@@ -1,30 +1,73 @@
-import { combineLatest, defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeWith, of, repeat, scan, takeUntil, tap, } from "rxjs";
+import { combineLatest, defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, ignoreElements, map, merge, mergeWith, of, repeat, scan, switchMap, take, takeUntil, tap, } from "rxjs";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { createReplaceableAddress, getEventUID, getReplaceableIdentifier, isReplaceable, matchFilters, } from "../helpers/index.js";
 import { claimEvents } from "../observable/claim-events.js";
 import { claimLatest } from "../observable/claim-latest.js";
+import { defined } from "../observable/defined.js";
 import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
+/** Gets a single event from both types of event stores and returns an observable that completes */
+function getEventFromStores(store, pointer) {
+    const r = store.getEvent(pointer.id);
+    if (r instanceof Promise)
+        return from(r);
+    else
+        return of(r);
+}
+/** Gets a single replaceable event from both types of event stores and returns an observable that completes */
+function getReplaceableFromStores(store, pointer) {
+    const r = store.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
+    if (r instanceof Promise)
+        return from(r);
+    else
+        return of(r);
+}
+/** If event is undefined, attempt to load using the fallback loader */
+function loadEventUsingFallback(store, pointer) {
+    return switchMap((event) => {
+        if (event)
+            return of(event);
+        // If event was not found, attempt to load
+        if (!store.eventLoader)
+            return EMPTY;
+        return from(store.eventLoader(pointer));
+    });
+}
+/** If replaceable event is undefined, attempt to load using the fallback loader */
+function loadReplaceableUsingFallback(store, pointer) {
+    return switchMap((event) => {
+        if (event)
+            return of(event);
+        else if (pointer.identifier !== undefined) {
+            if (!store.addressableLoader)
+                return EMPTY;
+            return from(store.addressableLoader(pointer)).pipe(filter((e) => !!e));
+        }
+        else {
+            if (!store.replaceableLoader)
+                return EMPTY;
+            return from(store.replaceableLoader(pointer)).pipe(filter((e) => !!e));
+        }
+    });
+}
 /** A model that returns a single event or undefined when its removed */
 export function EventModel(pointer) {
     if (typeof pointer === "string")
         pointer = { id: pointer };
-    return (events) => merge(
+    return (store) => merge(
     // get current event and ignore if there is none
-    defer(() => {
-        let event = events.getEvent(pointer.id);
-        if (event)
-            return of(event);
-        // If there is a loader, use it to get the event
-        if (!events.eventLoader)
-            return EMPTY;
-        return from(events.eventLoader(pointer)).pipe(filter((e) => !!e));
-    }), 
+    defer(() => getEventFromStores(store, pointer)).pipe(
+    // If the event isn't found, attempt to load using the fallback loader
+    loadEventUsingFallback(store, pointer), 
+    // Only emit found events
+    defined()), 
     // Listen for new events
-    events.insert$.pipe(filter((e) => e.id === pointer.id)), 
+    store.insert$.pipe(filter((e) => e.id === pointer.id)), 
     // emit undefined when deleted
-    events.removed(pointer.id).pipe(endWith(undefined))).pipe(
+    store.remove$.pipe(filter((e) => e.id === pointer.id), take(1), ignoreElements(), 
+    // Emit undefined when deleted
+    endWith(undefined))).pipe(
     // claim all events
-    claimLatest(events), 
+    claimLatest(store), 
     // ignore duplicate events
     distinctUntilChanged((a, b) => a?.id === b?.id), 
     // always emit undefined so the observable is synchronous
@@ -32,27 +75,17 @@ export function EventModel(pointer) {
 }
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
 export function ReplaceableModel(pointer) {
-    return (events) => {
+    return (store) => {
         let current = undefined;
         return merge(
         // lazily get current event
-        defer(() => {
-            let event = events.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
-            if (event)
-                return of(event);
-            else if (pointer.identifier !== undefined) {
-                if (!events.addressableLoader)
-                    return EMPTY;
-                return from(events.addressableLoader(pointer)).pipe(filter((e) => !!e));
-            }
-            else {
-                if (!events.replaceableLoader)
-                    return EMPTY;
-                return from(events.replaceableLoader(pointer)).pipe(filter((e) => !!e));
-            }
-        }), 
-        // subscribe to new events
-        events.insert$.pipe(filter((e) => e.pubkey == pointer.pubkey &&
+        defer(() => getReplaceableFromStores(store, pointer)).pipe(
+        // If the event isn't found, attempt to load using the fallback loader
+        loadReplaceableUsingFallback(store, pointer), 
+        // Only emit found events
+        defined()), 
+        // Subscribe to new events that match the pointer
+        store.insert$.pipe(filter((e) => e.pubkey == pointer.pubkey &&
             e.kind === pointer.kind &&
             (pointer.identifier !== undefined ? getReplaceableIdentifier(e) === pointer.identifier : true)))).pipe(
         // only update if event is newer
@@ -63,13 +96,13 @@ export function ReplaceableModel(pointer) {
         // Hacky way to extract the current event so takeUntil can access it
         tap((event) => (current = event)), 
         // complete when event is removed
-        takeUntil(events.remove$.pipe(filter((e) => e.id === current?.id))), 
+        takeUntil(store.remove$.pipe(filter((e) => e.id === current?.id))), 
         // emit undefined when removed
         endWith(undefined), 
         // keep the observable hot
         repeat(), 
         // claim latest event
-        claimLatest(events), 
+        claimLatest(store), 
         // always emit undefined so the observable is synchronous
         withImmediateValueOrDefault(undefined));
     };
@@ -77,18 +110,24 @@ export function ReplaceableModel(pointer) {
 /** A model that returns an array of sorted events matching the filters */
 export function TimelineModel(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
-    return (events) => {
+    return (store) => {
         const seen = new Map();
         // get current events
-        return defer(() => of(Array.from(events.getTimeline(filters)))).pipe(
+        return defer(() => {
+            const r = store.getTimeline(filters);
+            if (r instanceof Promise)
+                return from(r);
+            else
+                return of(r);
+        }).pipe(
         // claim existing events
-        claimEvents(events), 
+        claimEvents(store), 
         // subscribe to newer events
-        mergeWith(events.insert$.pipe(filter((e) => matchFilters(filters, e)), 
+        mergeWith(store.insert$.pipe(filter((e) => matchFilters(filters, e)), 
         // claim all new events
-        claimEvents(events))), 
+        claimEvents(store))), 
         // subscribe to delete events
-        mergeWith(events.remove$.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
+        mergeWith(store.remove$.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
         // build a timeline
         scan((timeline, event) => {
             // filter out removed events from timeline

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

@@ -2,6 +2,6 @@ import { NostrEvent } from "nostr-tools";
 import { Model } from "../event-store/interface.js";
 import { Rumor } from "../helpers/gift-wraps.js";
 /** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
-export declare function GiftWrapsModel(pubkey: string, locked?: boolean): Model<NostrEvent[]>;
+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

@@ -1,14 +1,14 @@
 import { kinds } from "nostr-tools";
 import { identity, map, of } from "rxjs";
-import { getGiftWrapRumor, isGiftWrapLocked } from "../helpers/gift-wraps.js";
+import { getGiftWrapRumor, isGiftWrapUnlocked } from "../helpers/gift-wraps.js";
 import { watchEventsUpdates, watchEventUpdates } from "../observable/watch-event-updates.js";
 /** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
-export function GiftWrapsModel(pubkey, locked) {
+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 lock is specified filter on locked status
-    locked !== undefined ? map((events) => events.filter((e) => isGiftWrapLocked(e) === locked)) : identity);
+    // 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) {

package/dist/models/index.d.ts

@@ -17,3 +17,4 @@ export * from "./relays.js";
 export * from "./thread.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
+export * from "./outbox.js";

package/dist/models/index.js

@@ -17,3 +17,4 @@ export * from "./relays.js";
 export * from "./thread.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
+export * from "./outbox.js";

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

@@ -7,8 +7,8 @@ export declare function LegacyMessagesGroups(self: string): Model<{
     lastMessage: NostrEvent;
 }[]>;
 /** Returns all legacy direct messages in a group */
-export declare function LegacyMessagesGroup(self: string, corraspondant: string): Model<NostrEvent[]>;
+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, corraspondant: string): Model<NostrEvent[]>;
+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

@@ -1,7 +1,8 @@
 import { kinds } from "nostr-tools";
-import { getLegacyMessageCorraspondant, getLegacyMessageParent } from "../helpers/legacy-messages.js";
+import { getLegacyMessageCorrespondent, getLegacyMessageParent } from "../helpers/legacy-messages.js";
 import { map } from "rxjs";
 import { getConversationIdentifierFromMessage, getConversationParticipants } from "../helpers/messages.js";
+import { hasNameValueTag } from "../helpers/event-tags.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) => {
@@ -19,41 +20,43 @@ export function LegacyMessagesGroups(self) {
     }));
 }
 /** Returns all legacy direct messages in a group */
-export function LegacyMessagesGroup(self, corraspondant) {
+export function LegacyMessagesGroup(self, correspondent) {
     return (store) => store.timeline([
         {
             kinds: [kinds.EncryptedDirectMessage],
             "#p": [self],
-            authors: [corraspondant],
+            authors: [correspondent],
         },
         {
             kinds: [kinds.EncryptedDirectMessage],
-            "#p": [corraspondant],
+            "#p": [correspondent],
             authors: [self],
         },
     ]);
 }
 /** Returns an array of legacy messages that have replies */
-export function LegacyMessageThreads(self, corraspondant) {
-    return (store) => store.model(LegacyMessagesGroup, self, corraspondant).pipe(map((messages) => messages.filter((message) => 
+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
-        store.getByFilters({ "#e": [message.id], kinds: [kinds.EncryptedDirectMessage] }).size > 0)));
+        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 corraspondant = getLegacyMessageCorraspondant(message, self);
+    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: [corraspondant],
+            authors: [correspondent],
             "#e": [message.id],
         },
         {
             kinds: [kinds.EncryptedDirectMessage],
-            "#p": [corraspondant],
+            "#p": [correspondent],
             authors: [self],
             "#e": [message.id],
         },

package/dist/models/outbox.d.ts

@@ -0,0 +1,13 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Model } from "../event-store/interface.js";
+import { SelectOptimalRelaysOptions } from "../helpers/relay-selection.js";
+import { ignoreBlacklistedRelays } from "../observable/relay-selection.js";
+export type OutboxModelOptions = SelectOptimalRelaysOptions & {
+    type?: "inbox" | "outbox";
+    blacklist?: Parameters<typeof ignoreBlacklistedRelays>[0];
+};
+/** A model that returns the users contacts with the relays to connect to */
+export declare function OutboxModel(user: string | ProfilePointer, opts: OutboxModelOptions): Model<ProfilePointer[]>;
+export declare namespace OutboxModel {
+    var getKey: (user: string | ProfilePointer, opts: OutboxModelOptions) => string;
+}

package/dist/models/outbox.js

@@ -0,0 +1,18 @@
+import hash_sum from "hash-sum";
+import { identity, map } from "rxjs";
+import { selectOptimalRelays } from "../helpers/relay-selection.js";
+import { ignoreBlacklistedRelays, includeMailboxes } from "../observable/relay-selection.js";
+/** A model that returns the users contacts with the relays to connect to */
+export function OutboxModel(user, opts) {
+    return (store) => store.contacts(user).pipe(
+    /** Ignore blacklisted relays */
+    opts?.blacklist ? ignoreBlacklistedRelays(opts.blacklist) : identity, 
+    /** Include mailboxes */
+    includeMailboxes(store, opts.type), 
+    /** Select the optimal relays */
+    map((users) => selectOptimalRelays(users, opts)));
+}
+OutboxModel.getKey = (user, opts) => {
+    const p = typeof user === "string" ? user : user.pubkey;
+    return hash_sum([p, opts.type, opts.maxConnections, opts.maxRelaysPerUser]);
+};

package/dist/models/profile.d.ts

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

package/dist/models/zaps.d.ts

@@ -1,9 +1,10 @@
-import { NostrEvent } from "nostr-tools";
+import { kinds } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
+import { KnownEvent } from "../helpers/index.js";
 /** A model that gets all zap events for an event */
-export declare function EventZapsModel(id: string | EventPointer | AddressPointer): Model<NostrEvent[]>;
+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<NostrEvent[]>;
+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<NostrEvent[]>;
+export declare function ReceivedZapsModel(pubkey: string): Model<KnownEvent<kinds.Zap>[]>;

package/dist/models/zaps.js

@@ -18,9 +18,9 @@ export function EventZapsModel(id) {
 }
 /** A model that returns all zaps sent by a user */
 export function SentZapsModel(pubkey) {
-    return (events) => events.timeline([{ kinds: [kinds.Zap], authors: [pubkey] }]);
+    return (events) => events.timeline([{ kinds: [kinds.Zap], authors: [pubkey] }]).pipe(map((events) => events.filter(isValidZap)));
 }
 /** A model that returns all zaps received by a user */
 export function ReceivedZapsModel(pubkey) {
-    return (events) => events.timeline([{ kinds: [kinds.Zap], "#a": [pubkey] }]);
+    return (events) => events.timeline([{ kinds: [kinds.Zap], "#p": [pubkey] }]).pipe(map((events) => events.filter(isValidZap)));
 }

package/dist/observable/index.d.ts

@@ -1,9 +1,10 @@
-import { firstValueFrom, lastValueFrom } from "rxjs";
+export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
+export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./map-events-timeline.js";
+export * from "./map-events-to-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 };
+export * from "./relay-selection.js";

package/dist/observable/index.js

@@ -1,10 +1,11 @@
-import { firstValueFrom, lastValueFrom } from "rxjs";
+// Re-export some useful rxjs functions
+export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
+export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./map-events-timeline.js";
+export * from "./map-events-to-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 };
+export * from "./relay-selection.js";

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

@@ -1,5 +1,7 @@
-import { MonoTypeOperatorFunction } from "rxjs";
 import { NostrEvent } from "nostr-tools";
-import { IEventStore } from "../event-store/interface.js";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IAsyncEventStoreActions, IEventStoreActions } 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>;
+export declare function mapEventsToStore(store: IEventStoreActions | IAsyncEventStoreActions, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;
+/** Alias for {@link mapEventsToStore} */
+export declare const filterDuplicateEvents: (store: IEventStoreActions | IAsyncEventStoreActions) => MonoTypeOperatorFunction<import("nostr-tools").Event>;

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

@@ -1,12 +1,23 @@
-import { distinct, filter, identity, map } from "rxjs";
+import { catchError, distinct, filter, from, identity, mergeMap, of } 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)), 
+    // NOTE: mergeMap is used here because we want to return the single instance of the event so that distinct() can be used later
+    mergeMap((event) => {
+        const r = store.add(event);
+        // Unwrap the promise from the async store
+        if (r instanceof Promise)
+            return from(r);
+        else
+            return of(r);
+    }), 
+    // Ignore errors when inserting events into the store
+    catchError(() => of(null)), 
     // Ignore invalid events
     filter((e) => e !== null), 
     // Remove duplicates if requested
     removeDuplicates ? distinct() : identity);
 }
+/** Alias for {@link mapEventsToStore} */
+export const filterDuplicateEvents = (store) => mapEventsToStore(store, true);

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

@@ -0,0 +1,12 @@
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { pipe, scan } from "rxjs";
+import { withImmediateValueOrDefault } from "./with-immediate-value.js";
+/**
+ * Accumulate events into an ordered timeline
+ * @note This does not remove duplicate events
+ */
+export function mapEventsToTimeline() {
+    return pipe(scan((timeline, event) => insertEventIntoDescendingList(timeline, event), []), 
+    // Emit an empty array first. This is to prevent empty observables completing without a value (EMPTY)
+    withImmediateValueOrDefault([]));
+}

package/dist/observable/relay-selection.d.ts

@@ -0,0 +1,9 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction } from "rxjs";
+import { IEventSubscriptions } from "../event-store/interface.js";
+/** RxJS operator that fetches outboxes for profile pointers from the event store */
+export declare function includeMailboxes(store: IEventSubscriptions, type?: "inbox" | "outbox"): OperatorFunction<ProfilePointer[], ProfilePointer[]>;
+/** Removes blacklisted relays from the user's relays */
+export declare function ignoreBlacklistedRelays(blacklist: string[] | Observable<string[]>): MonoTypeOperatorFunction<ProfilePointer[]>;
+/** Sets fallback relays for any user that has 0 relays */
+export declare function includeFallbackRelays(fallbacks: string[] | Observable<string[]>): MonoTypeOperatorFunction<ProfilePointer[]>;

package/dist/observable/relay-selection.js

@@ -0,0 +1,43 @@
+import { combineLatest, combineLatestWith, isObservable, map, of, pipe, switchMap, } from "rxjs";
+import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+import { addRelayHintsToPointer } from "../helpers/pointers.js";
+import { removeBlacklistedRelays, setFallbackRelays } from "../helpers/relay-selection.js";
+/** RxJS operator that fetches outboxes for profile pointers from the event store */
+export function includeMailboxes(store, type = "outbox") {
+    // Get the outboxes for all contacts
+    return switchMap((contacts) => combineLatest(contacts.map((user) => 
+    // Subscribe to the outboxes for the user
+    store
+        .replaceable({
+        kind: 10002,
+        pubkey: user.pubkey,
+    })
+        .pipe(
+    // Add the relays to the user
+    map((event) => {
+        if (!event)
+            return user;
+        // Get the relays from the event
+        const relays = type === "outbox" ? getOutboxes(event) : getInboxes(event);
+        if (!relays)
+            return user;
+        // Add the relays to the user
+        return addRelayHintsToPointer(user, relays);
+    })))));
+}
+/** Removes blacklisted relays from the user's relays */
+export function ignoreBlacklistedRelays(blacklist) {
+    return pipe(
+    // Combine with the observable so it re-emits when the blacklist changes
+    combineLatestWith(isObservable(blacklist) ? blacklist : of(blacklist)), 
+    // Filter the relays for the user
+    map(([users, blacklist]) => removeBlacklistedRelays(users, blacklist)));
+}
+/** Sets fallback relays for any user that has 0 relays */
+export function includeFallbackRelays(fallbacks) {
+    return pipe(
+    // Get the fallbacks from the observable
+    combineLatestWith(isObservable(fallbacks) ? fallbacks : of(fallbacks)), 
+    // Set the fallback relays for the users
+    map(([users, fallbacks]) => setFallbackRelays(users, fallbacks)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "3.1.0",
+  "version": "4.1.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -64,21 +64,23 @@
     "hash-sum": "^2.0.0",
     "light-bolt11-decoder": "^3.2.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "~2.15",
+    "nostr-tools": "~2.17",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
+    "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "vitest": "^3.2.4"
   },
   "funding": {
     "type": "lightning",
     "url": "lightning:nostrudel@geyser.fund"
   },
   "scripts": {
+    "prebuild": "rimraf dist",
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
     "test": "vitest run --passWithNoTests",

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

@@ -1,9 +0,0 @@
-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), []);
-}