applesauce-common 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

package/dist/casts/report.d.ts

@@ -0,0 +1,31 @@
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { ReportReason, ReportedEvent, ReportedUser } from "../helpers/reports.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+declare const REPORT_KIND = 1984;
+/** Cast a kind 1984 event to a Report */
+export declare class Report extends EventCast<KnownEvent<typeof REPORT_KIND>> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** Get the parsed report data (either a user or event report) */
+    get reported(): ReportedEvent | ReportedUser | null;
+    /** Check if this is a user report */
+    get isUserReport(): boolean;
+    /** Check if this is an event report */
+    get isEventReport(): boolean;
+    /** Get the reason for the report */
+    get reason(): ReportReason | undefined;
+    /** Get the comment/content of the report */
+    get comment(): string | undefined;
+    /** Get the pubkey of the user being reported */
+    get reportedPubkey(): string | undefined;
+    /** Get the User being reported */
+    get reportedUser(): import("./user.js").User | undefined;
+    /** Get the event ID being reported (for event reports) */
+    get reportedEventId(): string | undefined;
+    /** Get the event being reported (for event reports) */
+    get reportedEvent$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+    /** Get the blob hashes being reported (for event reports with x tags) */
+    get blobs(): string[] | undefined;
+    /** Get the server URLs for blob reports */
+    get servers(): string[];
+}
+export {};

package/dist/casts/report.js

@@ -0,0 +1,74 @@
+import { of } from "rxjs";
+import { getReportServers, getReported } from "../helpers/reports.js";
+import { EventCast } from "./cast.js";
+import { castUser } from "./user.js";
+import { addRelayHintsToPointer } from "applesauce-core/helpers";
+const REPORT_KIND = 1984;
+function isValidReport(event) {
+    return event.kind === REPORT_KIND;
+}
+/** Cast a kind 1984 event to a Report */
+export class Report extends EventCast {
+    constructor(event, store) {
+        if (!isValidReport(event))
+            throw new Error("Invalid report");
+        super(event, store);
+    }
+    /** Get the parsed report data (either a user or event report) */
+    get reported() {
+        return getReported(this.event);
+    }
+    /** Check if this is a user report */
+    get isUserReport() {
+        return this.reported?.type === "user";
+    }
+    /** Check if this is an event report */
+    get isEventReport() {
+        return this.reported?.type === "event";
+    }
+    /** Get the reason for the report */
+    get reason() {
+        return this.reported?.reason;
+    }
+    /** Get the comment/content of the report */
+    get comment() {
+        if (!this.reported)
+            return undefined;
+        return this.reported.type === "event" ? this.reported.comment : this.reported.comment;
+    }
+    /** Get the pubkey of the user being reported */
+    get reportedPubkey() {
+        return this.reported?.pubkey;
+    }
+    /** Get the User being reported */
+    get reportedUser() {
+        const pubkey = this.reportedPubkey;
+        if (!pubkey)
+            return undefined;
+        return castUser(pubkey, this.store);
+    }
+    /** Get the event ID being reported (for event reports) */
+    get reportedEventId() {
+        return this.reported?.type === "event" ? this.reported.id : undefined;
+    }
+    /** Get the event being reported (for event reports) */
+    get reportedEvent$() {
+        return this.$$ref("reportedEvent$", (store) => {
+            const eventId = this.reportedEventId;
+            if (!eventId)
+                return of(undefined);
+            const pointer = {
+                id: eventId,
+            };
+            return store.event(addRelayHintsToPointer(pointer, this.seen));
+        });
+    }
+    /** Get the blob hashes being reported (for event reports with x tags) */
+    get blobs() {
+        return this.reported?.type === "event" ? this.reported.blobs : undefined;
+    }
+    /** Get the server URLs for blob reports */
+    get servers() {
+        return getReportServers(this.event);
+    }
+}

package/dist/casts/share.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { ShareEvent } from "../helpers/share.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { Reaction } from "./reaction.js";
+/** Cast class for kind 6 and 16 share events */
+export declare class Share extends EventCast<ShareEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get sharedKind(): number | undefined;
+    get embedded(): import("nostr-tools").Event | undefined;
+    get sharedAddressPointer(): import("nostr-tools/nip19").AddressPointer | undefined;
+    get sharedEventPointer(): import("nostr-tools/nip19").EventPointer;
+    get sharedPointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer;
+    get shared$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+    get reactions$(): import("../observable/chainable.js").ChainableObservable<Reaction[]>;
+}

package/dist/casts/share.js

@@ -0,0 +1,34 @@
+import { getEmbededSharedEvent, getSharedAddressPointer, getSharedEventPointer, isValidShare, } from "../helpers/share.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { castTimelineStream } from "../observable/cast-stream.js";
+import { EventCast } from "./cast.js";
+import { Reaction } from "./reaction.js";
+/** Cast class for kind 6 and 16 share events */
+export class Share extends EventCast {
+    constructor(event, store) {
+        if (!isValidShare(event))
+            throw new Error("Invalid share");
+        super(event, store);
+    }
+    get sharedKind() {
+        return getSharedEventPointer(this.event)?.kind;
+    }
+    get embedded() {
+        return getEmbededSharedEvent(this.event);
+    }
+    get sharedAddressPointer() {
+        return getSharedAddressPointer(this.event);
+    }
+    get sharedEventPointer() {
+        return getSharedEventPointer(this.event);
+    }
+    get sharedPointer() {
+        return this.sharedAddressPointer || this.sharedEventPointer;
+    }
+    get shared$() {
+        return this.$$ref("shared$", (store) => store.event(this.sharedPointer));
+    }
+    get reactions$() {
+        return this.$$ref("reactions$", (store) => store.model(ReactionsModel, this.event).pipe(castTimelineStream(Reaction, store)));
+    }
+}

package/dist/casts/stream.d.ts

@@ -0,0 +1,43 @@
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { EventPointer } from "applesauce-core/helpers/pointers";
+import { StreamChatMessageEvent } from "../helpers/stream-chat.js";
+import { StreamStatus } from "../helpers/stream.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { Share } from "./share.js";
+import { Zap } from "./zap.js";
+/** Cast a kind 30311 event to a Stream (NIP-53) */
+export declare class Stream extends EventCast<KnownEvent<kinds.LiveEvent>> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get title(): string | undefined;
+    get summary(): string | undefined;
+    get image(): string | undefined;
+    get status(): StreamStatus;
+    get host(): import("./user.js").User;
+    get participants(): import("./user.js").User[];
+    get goalPointer(): EventPointer | undefined;
+    get streamingURLs(): string[];
+    get streamingVideos(): string[];
+    get streamingAudio(): string[];
+    get recording(): string | undefined;
+    get relays(): string[] | undefined;
+    get startTime(): number | undefined;
+    get endTime(): number | undefined;
+    get viewers(): number | undefined;
+    get maxViewers(): number | undefined;
+    get hashtags(): string[];
+    /** An observable of all zaps on this stream */
+    get zaps$(): import("../observable/chainable.js").ChainableObservable<Zap[]>;
+    get shares$(): import("../observable/chainable.js").ChainableObservable<Share[]>;
+    /** An observable of all chat messages for this stream */
+    get chat$(): import("../observable/chainable.js").ChainableObservable<StreamChatMessage[]>;
+    /** An observable of the goal event if this stream has a goal */
+    get goal$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+}
+/** A cast for a stream chat message */
+export declare class StreamChatMessage extends EventCast<StreamChatMessageEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get stream(): import("nostr-tools/nip19").AddressPointer;
+    get stream$(): import("../observable/chainable.js").ChainableObservable<Stream | undefined>;
+    get zaps$(): import("../observable/chainable.js").ChainableObservable<Zap[]>;
+    get reactions$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event[]>;
+}

package/dist/casts/stream.js

@@ -0,0 +1,116 @@
+import { isAudioURL, isStreamURL, isVideoURL } from "applesauce-core/helpers";
+import { kinds } from "applesauce-core/helpers/event";
+import { of } from "rxjs";
+import { getStreamChatMessageStream, isValidStreamChatMessage, } from "../helpers/stream-chat.js";
+import { getStreamEndTime, getStreamGoalPointer, getStreamHashtags, getStreamHost, getStreamImage, getStreamMaxViewers, getStreamParticipants, getStreamRecording, getStreamRelays, getStreamStartTime, getStreamStatus, getStreamStreamingURLs, getStreamSummary, getStreamTitle, getStreamViewers, } from "../helpers/stream.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { SharesModel } from "../models/shares.js";
+import { StreamChatMessagesModel } from "../models/stream.js";
+import { EventZapsModel } from "../models/zaps.js";
+import { castEventStream, castTimelineStream } from "../observable/cast-stream.js";
+import { EventCast } from "./cast.js";
+import { Share } from "./share.js";
+import { Zap } from "./zap.js";
+import { castUser } from "./user.js";
+function isValidStream(event) {
+    return event.kind === kinds.LiveEvent;
+}
+/** Cast a kind 30311 event to a Stream (NIP-53) */
+export class Stream extends EventCast {
+    constructor(event, store) {
+        if (!isValidStream(event))
+            throw new Error("Invalid stream");
+        super(event, store);
+    }
+    get title() {
+        return getStreamTitle(this.event);
+    }
+    get summary() {
+        return getStreamSummary(this.event);
+    }
+    get image() {
+        return getStreamImage(this.event);
+    }
+    get status() {
+        return getStreamStatus(this.event);
+    }
+    get host() {
+        return castUser(getStreamHost(this.event), this.store);
+    }
+    get participants() {
+        return getStreamParticipants(this.event).map((p) => castUser(p, this.store));
+    }
+    get goalPointer() {
+        return getStreamGoalPointer(this.event);
+    }
+    get streamingURLs() {
+        return getStreamStreamingURLs(this.event);
+    }
+    get streamingVideos() {
+        return this.streamingURLs.filter((url) => isVideoURL(url) || isStreamURL(url));
+    }
+    get streamingAudio() {
+        return this.streamingURLs.filter((url) => isAudioURL(url) || isStreamURL(url));
+    }
+    get recording() {
+        return getStreamRecording(this.event);
+    }
+    get relays() {
+        return getStreamRelays(this.event);
+    }
+    get startTime() {
+        return getStreamStartTime(this.event);
+    }
+    get endTime() {
+        return getStreamEndTime(this.event);
+    }
+    get viewers() {
+        return getStreamViewers(this.event);
+    }
+    get maxViewers() {
+        return getStreamMaxViewers(this.event);
+    }
+    get hashtags() {
+        return getStreamHashtags(this.event);
+    }
+    /** An observable of all zaps on this stream */
+    get zaps$() {
+        return this.$$ref("zaps$", (store) => store.model(EventZapsModel, this.event).pipe(castTimelineStream(Zap, store)));
+    }
+    get shares$() {
+        return this.$$ref("shares$", (store) => store.model(SharesModel, this.event).pipe(castTimelineStream(Share, store)));
+    }
+    /** An observable of all chat messages for this stream */
+    get chat$() {
+        return this.$$ref("chat$", (store) => store.model(StreamChatMessagesModel, this.event).pipe(castTimelineStream(StreamChatMessage, store)));
+    }
+    /** An observable of the goal event if this stream has a goal */
+    get goal$() {
+        return this.$$ref("goal$", (store) => {
+            const goalPointer = this.goalPointer;
+            if (!goalPointer)
+                return of(undefined);
+            return store.event(goalPointer.id);
+        });
+    }
+}
+/** A cast for a stream chat message */
+export class StreamChatMessage extends EventCast {
+    constructor(event, store) {
+        if (!isValidStreamChatMessage(event))
+            throw new Error("Invalid stream chat message");
+        super(event, store);
+    }
+    get stream() {
+        return getStreamChatMessageStream(this.event);
+    }
+    get stream$() {
+        return this.$$ref("stream$", (store) => store.replaceable(this.stream).pipe(castEventStream(Stream, store)));
+    }
+    get zaps$() {
+        return this.$$ref("zaps$", (store) => store.model(EventZapsModel, this.event).pipe(castTimelineStream(Zap, store)));
+    }
+    get reactions$() {
+        return this.$$ref("reactions$", (store) => store.model(ReactionsModel, this.event));
+    }
+}

package/dist/casts/torrent.d.ts

@@ -0,0 +1,31 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { TorrentEvent } from "../helpers/torrent.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { Comment } from "./comment.js";
+import { Reaction } from "./reaction.js";
+import { Zap } from "./zap.js";
+export declare class Torrent extends EventCast<TorrentEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** The BitTorrent info hash from the `x` tag */
+    get infoHash(): string;
+    /** The torrent title from the `title` tag */
+    get title(): string | undefined;
+    /** All file entries from `file` tags */
+    get files(): import("../helpers/torrent.js").TorrentFile[];
+    /** All tracker URLs from `tracker` tags */
+    get trackers(): string[];
+    /** The newznab category ID from the `i` tag with `newznab:` prefix */
+    get category(): number | undefined;
+    /** All search tags (for searchability) from `t` tags */
+    get searchTags(): string[];
+    /** The category path from the `tcat` identifier in `i` tags (e.g., "video,movie,4k") */
+    get categoryPath(): string | undefined;
+    /** All external identifiers from `i` tags (excluding tcat and newznab, which are handled separately) */
+    get externalIdentifiers(): import("../helpers/torrent.js").TorrentExternalIdentifier[];
+    /** The magnet link for the torrent, built from the info hash, trackers, and title */
+    get magnetLink(): string | undefined;
+    /** Gets the NIP-22 comments to this event */
+    get comments$(): import("../observable/chainable.js").ChainableObservable<Comment[]>;
+    get zaps$(): import("../observable/chainable.js").ChainableObservable<Zap[]>;
+    get reactions$(): import("../observable/chainable.js").ChainableObservable<Reaction[]>;
+}

package/dist/casts/torrent.js

@@ -0,0 +1,62 @@
+import { getTorrentCategory, getTorrentCategoryPath, getTorrentExternalIdentifiers, getTorrentFiles, getTorrentInfoHash, getTorrentMagnetLink, getTorrentSearchTags, getTorrentTitle, getTorrentTrackers, isValidTorrent, } from "../helpers/torrent.js";
+import { CommentsModel } from "../models/comments.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { EventZapsModel } from "../models/zaps.js";
+import { castTimelineStream } from "../observable/cast-stream.js";
+import { EventCast } from "./cast.js";
+import { Comment } from "./comment.js";
+import { Reaction } from "./reaction.js";
+import { Zap } from "./zap.js";
+export class Torrent extends EventCast {
+    constructor(event, store) {
+        if (!isValidTorrent(event))
+            throw new Error("Invalid torrent");
+        super(event, store);
+    }
+    /** The BitTorrent info hash from the `x` tag */
+    get infoHash() {
+        return getTorrentInfoHash(this.event);
+    }
+    /** The torrent title from the `title` tag */
+    get title() {
+        return getTorrentTitle(this.event);
+    }
+    /** All file entries from `file` tags */
+    get files() {
+        return getTorrentFiles(this.event);
+    }
+    /** All tracker URLs from `tracker` tags */
+    get trackers() {
+        return getTorrentTrackers(this.event);
+    }
+    /** The newznab category ID from the `i` tag with `newznab:` prefix */
+    get category() {
+        return getTorrentCategory(this.event);
+    }
+    /** All search tags (for searchability) from `t` tags */
+    get searchTags() {
+        return getTorrentSearchTags(this.event);
+    }
+    /** The category path from the `tcat` identifier in `i` tags (e.g., "video,movie,4k") */
+    get categoryPath() {
+        return getTorrentCategoryPath(this.event);
+    }
+    /** All external identifiers from `i` tags (excluding tcat and newznab, which are handled separately) */
+    get externalIdentifiers() {
+        return getTorrentExternalIdentifiers(this.event);
+    }
+    /** The magnet link for the torrent, built from the info hash, trackers, and title */
+    get magnetLink() {
+        return getTorrentMagnetLink(this.event);
+    }
+    /** Gets the NIP-22 comments to this event */
+    get comments$() {
+        return this.$$ref("comments$", (store) => store.model(CommentsModel, this.event).pipe(castTimelineStream(Comment, store)));
+    }
+    get zaps$() {
+        return this.$$ref("zaps$", (store) => store.model(EventZapsModel, this.event).pipe(castTimelineStream(Zap, store)));
+    }
+    get reactions$() {
+        return this.$$ref("reactions$", (store) => store.model(ReactionsModel, this.event).pipe(castTimelineStream(Reaction, store)));
+    }
+}

package/dist/casts/user.d.ts

@@ -0,0 +1,40 @@
+import { NostrEvent, ProfilePointer } from "applesauce-core/helpers";
+import { Observable } from "rxjs";
+import { ChainableObservable } from "../observable/chainable.js";
+import { type CastRefEventStore } from "./cast.js";
+/** Cast a nostr event or pointer into a {@link User} */
+export declare function castUser(event: NostrEvent, store: CastRefEventStore): User;
+export declare function castUser(user: string | ProfilePointer, store: CastRefEventStore): User;
+/** A class for a user */
+export declare class User {
+    #private;
+    pubkey: string;
+    /** A global cache of pubkey -> {@link User} */
+    static cache: Map<string, User>;
+    constructor(user: string | ProfilePointer, store: CastRefEventStore);
+    /** Internal method for creating a reference */
+    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
+    get npub(): `npub1${string}`;
+    get pointer(): ProfilePointer;
+    get nprofile(): `nprofile1${string}`;
+    replaceable(kind: number, identifier?: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    addressable(kind: number, identifier: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    get profile$(): ChainableObservable<import("./profile.js").Profile | undefined>;
+    get contacts$(): ChainableObservable<User[]>;
+    get mutes$(): ChainableObservable<import("./mutes.js").Mutes | undefined>;
+    get mailboxes$(): ChainableObservable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    get outboxes$(): ChainableObservable<string[] | undefined>;
+    get inboxes$(): ChainableObservable<string[] | undefined>;
+    get bookmarks$(): ChainableObservable<import("./bookmarks.js").BookmarksList | undefined>;
+    get favoriteRelays$(): ChainableObservable<import("./relay-lists.js").FavoriteRelays | undefined>;
+    get searchRelays$(): ChainableObservable<import("./relay-lists.js").SearchRelays | undefined>;
+    get blockedRelays$(): ChainableObservable<import("./relay-lists.js").BlockedRelays | undefined>;
+    get directMessageRelays$(): ChainableObservable<string[] | undefined>;
+    /** Gets the users list of NIP-29 groups */
+    get groups$(): ChainableObservable<import("./groups.js").GroupsList | undefined>;
+    /** Get the latest live stream for the user */
+    get live$(): ChainableObservable<import("./stream.js").Stream | undefined>;
+}

package/dist/casts/user.js

@@ -0,0 +1,181 @@
+import { isEvent, isHexKey, kinds, nprofileEncode, npubEncode, } from "applesauce-core/helpers";
+import { combineLatest, defer, from, map, switchMap, tap } from "rxjs";
+import { GROUPS_LIST_KIND } from "../helpers/groups.js";
+import { getRelaysFromList } from "../helpers/lists.js";
+import { FAVORITE_RELAYS_KIND } from "../helpers/relay-list.js";
+import { castEventStream } from "../observable/cast-stream.js";
+import { chainable } from "../observable/chainable.js";
+export function castUser(user, store) {
+    if (isEvent(user)) {
+        return castUser(user.pubkey, store);
+    }
+    else {
+        const pubkey = typeof user === "string" ? user : user.pubkey;
+        // Skip creating a new instance if this pubkey has already been cast
+        const existing = User.cache.get(pubkey);
+        if (existing)
+            return existing;
+        // Create a new instance and cache it
+        const newUser = new User(pubkey, store);
+        User.cache.set(pubkey, newUser);
+        return newUser;
+    }
+}
+// IMPORTANT: this class MUST use async import() to import the other classes so that we do not get circular dependency errors
+/** A class for a user */
+export class User {
+    pubkey;
+    #store;
+    /** A cache of the users outboxes for creating a profile pointer relay hints */
+    #outboxes;
+    /** A global cache of pubkey -> {@link User} */
+    static cache = new Map();
+    constructor(user, store) {
+        if (typeof user === "string" && !isHexKey(user))
+            throw new Error("Invalid pubkey for user");
+        const pubkey = typeof user === "string" ? user : user.pubkey;
+        this.#store = store;
+        this.pubkey = pubkey;
+    }
+    /** A cache of observable references */
+    #refs = {};
+    /** Internal method for creating a reference */
+    $$ref(key, builder) {
+        // Return cached observable
+        if (this.#refs[key])
+            return this.#refs[key];
+        // Build a new observable and cache it
+        const observable = chainable(builder(this.#store));
+        this.#refs[key] = observable;
+        return observable;
+    }
+    // Public getters
+    get npub() {
+        return npubEncode(this.pubkey);
+    }
+    get pointer() {
+        return {
+            pubkey: this.pubkey,
+            relays: this.#outboxes?.slice(0, 3) ?? [],
+        };
+    }
+    get nprofile() {
+        return nprofileEncode(this.pointer);
+    }
+    // Request methods
+    replaceable(kind, identifier, relays) {
+        return chainable(this.#store.replaceable({ kind, pubkey: this.pubkey, identifier, relays }));
+    }
+    addressable(kind, identifier, relays) {
+        return chainable(this.#store.addressable({ kind, pubkey: this.pubkey, identifier, relays }));
+    }
+    // Observable interfaces
+    get profile$() {
+        return this.$$ref("profile$", (store) => defer(() => from(import("./profile.js").then((m) => m.Profile))).pipe(switchMap((Profile) => store.replaceable({ kind: kinds.Metadata, pubkey: this.pubkey }).pipe(castEventStream(Profile, store)))));
+    }
+    get contacts$() {
+        return this.$$ref("contacts$", (store) => this.outboxes$.pipe(
+        // Fetch the contacts from the outboxes
+        switchMap((outboxes) => store.contacts({ pubkey: this.pubkey, relays: outboxes })), 
+        // Cast to users
+        map((arr) => arr.map((p) => castUser(p, this.#store)))));
+    }
+    get mutes$() {
+        return this.$$ref("mutes$", (store) => combineLatest([
+            // Import the Mutes class
+            defer(() => import("./mutes.js").then((m) => m.Mutes)),
+            // Always start without the outboxes
+            this.outboxes$,
+        ]).pipe(
+        // Create the mute list event with the outboxes
+        switchMap(([Mutes, outboxes]) => store
+            .event({ kind: kinds.Mutelist, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(Mutes, store)))));
+    }
+    get mailboxes$() {
+        return this.$$ref("mailboxes$", (store) => store.mailboxes({ pubkey: this.pubkey }).pipe(
+        // Cache the outboxes for creating a profile pointer relay hints
+        tap((mailboxes) => (this.#outboxes = mailboxes?.outboxes))));
+    }
+    get outboxes$() {
+        return this.mailboxes$.outboxes;
+    }
+    get inboxes$() {
+        return this.mailboxes$.inboxes;
+    }
+    get bookmarks$() {
+        return this.$$ref("bookmarks$", (store) => combineLatest([
+            // Import the BookmarksList class
+            defer(() => from(import("./bookmarks.js").then((m) => m.BookmarksList))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(switchMap(([BookmarksList, outboxes]) => 
+        // Fetch the bookmarks list event from the outboxes
+        store
+            .replaceable({ kind: kinds.BookmarkList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(BookmarksList, store)))));
+    }
+    get favoriteRelays$() {
+        return this.$$ref("favoriteRelays$", (store) => combineLatest([
+            // Import the FavoriteRelays class
+            defer(() => from(import("./relay-lists.js").then((m) => m.FavoriteRelays))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(
+        // Fetch the favorite relays list event from the outboxes
+        switchMap(([FavoriteRelaysList, outboxes]) => store
+            .replaceable({ kind: FAVORITE_RELAYS_KIND, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(FavoriteRelaysList, store)))));
+    }
+    get searchRelays$() {
+        return this.$$ref("searchRelays$", (store) => combineLatest([
+            // Import the SearchRelays class
+            defer(() => from(import("./relay-lists.js").then((m) => m.SearchRelays))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(
+        // Fetch the search relays list event from the outboxes
+        switchMap(([SearchRelaysList, outboxes]) => store
+            .replaceable({ kind: kinds.SearchRelaysList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(SearchRelaysList, store)))));
+    }
+    get blockedRelays$() {
+        return this.$$ref("blockedRelays$", (store) => combineLatest([
+            // Import the BlockedRelays class
+            defer(() => from(import("./relay-lists.js").then((m) => m.BlockedRelays))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(
+        // Fetch the blocked relays list event from the outboxes
+        switchMap(([BlockedRelaysList, outboxes]) => store
+            .replaceable({ kind: kinds.BlockedRelaysList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(BlockedRelaysList, store)))));
+    }
+    get directMessageRelays$() {
+        return this.$$ref("dmRelays$", (store) => this.outboxes$.pipe(
+        // Fetch the DM relays list event from the outboxes
+        switchMap((outboxes) => store
+            .replaceable({ kind: kinds.DirectMessageRelaysList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(map((event) => event && getRelaysFromList(event))))));
+    }
+    /** Gets the users list of NIP-29 groups */
+    get groups$() {
+        return this.$$ref("groups$", (store) => combineLatest([
+            // Import the BlockedRelays class
+            defer(() => from(import("./groups.js").then((m) => m.GroupsList))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(switchMap(([GroupsList, outboxes]) => store
+            .replaceable({ kind: GROUPS_LIST_KIND, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(GroupsList, store)))));
+    }
+    /** Get the latest live stream for the user */
+    get live$() {
+        return this.$$ref("live$", (store) => defer(() => import("./stream.js").then((m) => m.Stream)).pipe(switchMap((Stream) => store
+            .timeline([
+            { kinds: [kinds.LiveEvent], "#p": [this.pubkey] },
+            { kinds: [kinds.LiveEvent], authors: [this.pubkey] },
+        ])
+            .pipe(map((events) => events[0]), castEventStream(Stream, store)))));
+    }
+}

package/dist/casts/zap.d.ts

@@ -0,0 +1,17 @@
+import { NostrEvent } from "applesauce-core/helpers";
+import { ZapEvent } from "../helpers/zap.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Cast a kind 9735 event to a Zap */
+export declare class Zap extends EventCast<ZapEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get sender(): import("./user.js").User;
+    get recipient(): import("./user.js").User;
+    get payment(): import("../helpers/bolt11.js").ParsedInvoice;
+    get amount(): number;
+    get preimage(): string | undefined;
+    get request(): import("nostr-tools").Event;
+    get addressPointer(): import("nostr-tools/nip19").AddressPointer | null;
+    get eventPointer(): import("nostr-tools/nip19").EventPointer | null;
+    /** An observable of the zapped event */
+    get event$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+}