applesauce-core 2.3.0 → 3.0.1

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>>;

package/dist/models/common.js

@@ -1,40 +1,60 @@
-import { 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, map, merge, mergeWith, of, repeat, scan, 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 { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
 /** A model that returns a single event or undefined when its removed */
-export function EventModel(id) {
+export function EventModel(pointer) {
+    if (typeof pointer === "string")
+        pointer = { id: pointer };
     return (events) => merge(
     // get current event and ignore if there is none
     defer(() => {
-        let event = events.getEvent(id);
-        return event ? of(event) : EMPTY;
+        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));
     }), 
-    // subscribe to updates
-    events.insert$.pipe(filter((e) => e.id === id)), 
-    // subscribe to updates
-    events.updated(id), 
+    // Listen for new events
+    events.insert$.pipe(filter((e) => e.id === pointer.id)), 
     // emit undefined when deleted
-    events.removed(id).pipe(endWith(undefined))).pipe(
+    events.removed(pointer.id).pipe(endWith(undefined))).pipe(
     // claim all events
     claimLatest(events), 
+    // ignore duplicate events
+    distinctUntilChanged((a, b) => a?.id === b?.id), 
     // always emit undefined so the observable is synchronous
     withImmediateValueOrDefault(undefined));
 }
 /** A model that returns the latest version of a replaceable event or undefined if its removed */
-export function ReplaceableModel(kind, pubkey, d) {
+export function ReplaceableModel(pointer) {
     return (events) => {
         let current = undefined;
         return merge(
         // lazily get current event
         defer(() => {
-            let event = events.getReplaceable(kind, pubkey, d);
-            return event ? of(event) : EMPTY;
+            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 == pubkey && e.kind === kind && (d !== undefined ? getReplaceableIdentifier(e) === d : true)))).pipe(
+        events.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
         distinctUntilChanged((prev, event) => {
             // are the events the same? i.e. is the prev event older
@@ -108,69 +128,20 @@ export function TimelineModel(filters, includeOldVersion) {
         finalize(() => seen.clear()));
     };
 }
-/** A model that returns a multiple events in a map */
+/**
+ * A model that returns a multiple events in a map
+ * @deprecated use multiple {@link EventModel} instead
+ */
 export function EventsModel(ids) {
-    return (events) => merge(
-    // lazily get existing events
-    defer(() => from(ids.map((id) => events.getEvent(id)))), 
-    // subscribe to new events
-    events.insert$.pipe(filter((e) => ids.includes(e.id))), 
-    // subscribe to updates
-    events.update$.pipe(filter((e) => ids.includes(e.id)))).pipe(
-    // ignore empty messages
-    filter((e) => !!e), 
-    // claim all events until cleanup
-    claimEvents(events), 
-    // watch for removed events
-    mergeWith(events.remove$.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
-    // merge all events into a directory
-    scan((dir, event) => {
-        if (typeof event === "string") {
-            // delete event by id
-            const clone = { ...dir };
-            delete clone[event];
-            return clone;
-        }
-        else {
-            // add even to directory
-            return { ...dir, [event.id]: event };
-        }
-    }, {}));
+    return (events) => combineLatest(Object.fromEntries(ids.map((id) => [id, events.model(EventModel, { id })])));
 }
-/** A model that returns a directory of events by their UID */
+/**
+ * A model that returns a directory of events by their UID
+ * @deprecated use multiple {@link ReplaceableModel} instead
+ */
 export function ReplaceableSetModel(pointers) {
-    return (events) => {
-        const uids = new Set(pointers.map((p) => createReplaceableAddress(p.kind, p.pubkey, p.identifier)));
-        return merge(
-        // start with existing events
-        defer(() => from(pointers.map((p) => events.getReplaceable(p.kind, p.pubkey, p.identifier)))), 
-        // subscribe to new events
-        events.insert$.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
-        // filter out undefined
-        filter((e) => !!e), 
-        // claim all events
-        claimEvents(events), 
-        // convert events to add commands
-        map((e) => ["add", e]), 
-        // watch for removed events
-        mergeWith(events.remove$.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))), map((e) => ["remove", e]))), 
-        // reduce events into directory
-        scan((dir, [action, event]) => {
-            const uid = getEventUID(event);
-            if (action === "add") {
-                // add event to dir if its newer
-                if (!dir[uid] || dir[uid].created_at < event.created_at)
-                    return { ...dir, [uid]: event };
-            }
-            else if (action === "remove" && dir[uid] === event) {
-                // remove event from dir
-                let newDir = { ...dir };
-                delete newDir[uid];
-                return newDir;
-            }
-            return dir;
-        }, {}), 
-        // ignore changes that do not modify the directory
-        distinctUntilChanged());
-    };
+    return (events) => combineLatest(Object.fromEntries(pointers.map((pointer) => [
+        createReplaceableAddress(pointer.kind, pointer.pubkey, pointer.identifier),
+        events.model(ReplaceableModel, pointer),
+    ])));
 }

package/dist/models/contacts.d.ts

@@ -1,7 +1,7 @@
 import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
 /** A model that returns all contacts for a user */
-export declare function ContactsModel(pubkey: string): Model<ProfilePointer[]>;
+export declare function ContactsModel(user: string | ProfilePointer): Model<ProfilePointer[]>;
 /** A model that returns all public contacts for a user */
 export declare function PublicContactsModel(pubkey: string): Model<ProfilePointer[] | undefined>;
 /** A model that returns all hidden contacts for a user */

package/dist/models/contacts.js

@@ -3,8 +3,10 @@ import { map } from "rxjs/operators";
 import { getContacts, getHiddenContacts, getPublicContacts } from "../helpers/contacts.js";
 import { watchEventUpdates } from "../observable/index.js";
 /** A model that returns all contacts for a user */
-export function ContactsModel(pubkey) {
-    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+export function ContactsModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.Contacts, pubkey: user.pubkey, relays: user.relays }).pipe(
     // listen for event updates (hidden tags unlocked)
     watchEventUpdates(events), 
     // Get all contacts

package/dist/models/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./blossom.js";
 export * from "./bookmarks.js";
+export * from "./calendar.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./common.js";

package/dist/models/index.js

@@ -1,5 +1,6 @@
 export * from "./blossom.js";
 export * from "./bookmarks.js";
+export * from "./calendar.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./common.js";

package/dist/models/mailboxes.d.ts

@@ -1,6 +1,7 @@
+import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
 /** A model that gets and parses the inbox and outbox relays for a pubkey */
-export declare function MailboxesModel(pubkey: string): Model<{
+export declare function MailboxesModel(user: string | ProfilePointer): Model<{
     inboxes: string[];
     outboxes: string[];
 } | undefined>;

package/dist/models/mailboxes.js

@@ -2,8 +2,10 @@ import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 /** 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 && {
+export function MailboxesModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.RelayList, pubkey: user.pubkey, relays: user.relays }).pipe(map((event) => event && {
         inboxes: getInboxes(event),
         outboxes: getOutboxes(event),
     }));

package/dist/models/mutes.d.ts

@@ -1,7 +1,8 @@
-import { Mutes } from "../helpers/mutes.js";
+import { ProfilePointer } from "nostr-tools/nip19";
 import { Model } from "../event-store/interface.js";
+import { Mutes } from "../helpers/mutes.js";
 /** A model that returns all a users muted things */
-export declare function MuteModel(pubkey: string): Model<Mutes | undefined>;
+export declare function MuteModel(user: string | ProfilePointer): Model<Mutes | undefined>;
 /** A model that returns all a users public muted things */
 export declare function PublicMuteModel(pubkey: string): Model<Mutes | undefined>;
 /** A model that returns all a users hidden muted things */

package/dist/models/mutes.js

@@ -3,8 +3,10 @@ import { map } from "rxjs/operators";
 import { getHiddenMutedThings, getMutedThings, getPublicMutedThings } from "../helpers/mutes.js";
 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(
+export function MuteModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.Mutelist, pubkey: user.pubkey, relays: user.relays }).pipe(
     // listen for event updates (hidden tags unlocked)
     watchEventUpdates(events), 
     // Get all muted things

package/dist/models/profile.d.ts

@@ -1,4 +1,5 @@
 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(pubkey: string): Model<ProfileContent | undefined>;
+export declare function ProfileModel(user: string | ProfilePointer): Model<ProfileContent | undefined>;

package/dist/models/profile.js

@@ -3,8 +3,10 @@ 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(
+export function ProfileModel(user) {
+    if (typeof user === "string")
+        user = { pubkey: user };
+    return (events) => events.replaceable({ kind: kinds.Metadata, pubkey: user.pubkey, relays: user.relays }).pipe(
     // Filter out invalid profile events
     filter(isValidProfile), 
     // Parse the profile event into a ProfileContent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "2.3.0",
+  "version": "3.0.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",

package/dist/event-store/common.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/event-store/common.js

@@ -1 +0,0 @@
-export {};