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

package/dist/casts/groups.js

@@ -0,0 +1,43 @@
+import { hasHiddenContent } from "applesauce-core/helpers";
+import { watchEventUpdates } from "applesauce-core/observable";
+import { map, of } from "rxjs";
+import { getHiddenGroups, getPublicGroups, GROUPS_LIST_KIND, isHiddenGroupsUnlocked, unlockHiddenGroups, } from "../helpers/groups.js";
+import { EventCast } from "./cast.js";
+function isValidGroupsList(event) {
+    return event.kind === GROUPS_LIST_KIND;
+}
+export class GroupsList extends EventCast {
+    constructor(event, store) {
+        if (!isValidGroupsList(event))
+            throw new Error("Invalid groups list");
+        super(event, store);
+    }
+    /** The public groups in the list */
+    get groups() {
+        return getPublicGroups(this.event);
+    }
+    /** Get the unlocked hidden groups */
+    get hidden() {
+        return getHiddenGroups(this.event);
+    }
+    /** An observable that updates when hidden groups are unlocked */
+    get hidden$() {
+        return this.$$ref("hidden$", (store) => of(this.event).pipe(
+        // Watch for event updates
+        watchEventUpdates(store), 
+        // Get hidden groups
+        map((event) => event && getHiddenGroups(event))));
+    }
+    /** Whether the groups list has hidden groups */
+    get hasHidden() {
+        return hasHiddenContent(this.event);
+    }
+    /** Whether the groups list is unlocked */
+    get unlocked() {
+        return isHiddenGroupsUnlocked(this.event);
+    }
+    /** Unlocks the hidden groups on the groups list */
+    async unlock(signer) {
+        return unlockHiddenGroups(this.event, signer);
+    }
+}

package/dist/casts/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./article.js";
+export * from "./bookmarks.js";
+export * from "./cast.js";
+export * from "./comment.js";
+export * from "./groups.js";
+export * from "./mutes.js";
+export * from "./note.js";
+export * from "./profile.js";
+export * from "./reaction.js";
+export * from "./relay-discovery.js";
+export * from "./relay-lists.js";
+export * from "./relay-monitor.js";
+export * from "./report.js";
+export * from "./share.js";
+export * from "./stream.js";
+export * from "./torrent.js";
+export * from "./user.js";
+export * from "./zap.js";

package/dist/casts/index.js

@@ -0,0 +1,18 @@
+export * from "./article.js";
+export * from "./bookmarks.js";
+export * from "./cast.js";
+export * from "./comment.js";
+export * from "./groups.js";
+export * from "./mutes.js";
+export * from "./note.js";
+export * from "./profile.js";
+export * from "./reaction.js";
+export * from "./relay-discovery.js";
+export * from "./relay-lists.js";
+export * from "./relay-monitor.js";
+export * from "./report.js";
+export * from "./share.js";
+export * from "./stream.js";
+export * from "./torrent.js";
+export * from "./user.js";
+export * from "./zap.js";

package/dist/casts/mutes.d.ts

@@ -0,0 +1,23 @@
+import { NostrEvent } from "applesauce-core/helpers";
+import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
+import { MuteListEvent, type MutedThings } from "../helpers/mute.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Class for mute lists (kind 10000) */
+export declare class Mutes extends EventCast<MuteListEvent> implements MutedThings {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get mutes(): MutedThings;
+    get hashtags(): Set<string>;
+    get words(): Set<string>;
+    get pubkeys(): Set<string>;
+    get threads(): Set<string>;
+    /** Get the unlocked hidden mutes */
+    get hidden(): MutedThings | undefined;
+    /** An observable that updates when hidden mutes are unlocked */
+    get hidden$(): import("../observable/chainable.js").ChainableObservable<MutedThings>;
+    /** Whether the mute list has hidden mutes */
+    get hasHidden(): boolean;
+    /** Whether the mute list is unlocked */
+    get unlocked(): boolean;
+    /** Unlocks the hidden mutes on the mute list */
+    unlock(signer: HiddenContentSigner): Promise<MutedThings>;
+}

package/dist/casts/mutes.js

@@ -0,0 +1,54 @@
+import { defined, watchEventUpdates } from "applesauce-core";
+import { hasHiddenTags } from "applesauce-core/helpers";
+import { map, of } from "rxjs";
+import { getHiddenMutedThings, getPublicMutedThings, isHiddenMutesUnlocked, isValidMuteList, unlockHiddenMutes, } from "../helpers/mute.js";
+import { EventCast } from "./cast.js";
+/** Class for mute lists (kind 10000) */
+export class Mutes extends EventCast {
+    constructor(event, store) {
+        if (!isValidMuteList(event))
+            throw new Error("Invalid mute list");
+        super(event, store);
+    }
+    get mutes() {
+        return getPublicMutedThings(this.event);
+    }
+    get hashtags() {
+        return this.mutes.hashtags;
+    }
+    get words() {
+        return this.mutes.words;
+    }
+    get pubkeys() {
+        return this.mutes.pubkeys;
+    }
+    get threads() {
+        return this.mutes.threads;
+    }
+    /** Get the unlocked hidden mutes */
+    get hidden() {
+        return getHiddenMutedThings(this.event);
+    }
+    /** An observable that updates when hidden mutes are unlocked */
+    get hidden$() {
+        return this.$$ref("hidden$", (store) => of(this.event).pipe(
+        // Watch for event updates
+        watchEventUpdates(store), 
+        // Get hidden mutes
+        map((event) => event && getHiddenMutedThings(event)), 
+        // Only emit when the hidden mutes are unlocked
+        defined()));
+    }
+    /** Whether the mute list has hidden mutes */
+    get hasHidden() {
+        return hasHiddenTags(this.event);
+    }
+    /** Whether the mute list is unlocked */
+    get unlocked() {
+        return isHiddenMutesUnlocked(this.event);
+    }
+    /** Unlocks the hidden mutes on the mute list */
+    unlock(signer) {
+        return unlockHiddenMutes(this.event, signer);
+    }
+}

package/dist/casts/note.d.ts

@@ -0,0 +1,25 @@
+import { EventPointer, KnownEvent, NostrEvent } from "applesauce-core/helpers";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { Comment } from "./comment.js";
+import { Reaction } from "./reaction.js";
+import { Share } from "./share.js";
+import { Zap } from "./zap.js";
+export declare class Note extends EventCast<KnownEvent<1>> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get references(): import("../helpers/threading.js").ThreadReferences;
+    get isReply(): boolean;
+    get isRoot(): boolean;
+    /** An array of events that this note is quoting */
+    get quotePointers(): EventPointer[];
+    /** Gets the NIP-10 root event */
+    get threadRoot$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+    /** Gets the NIP-10 reply event */
+    get replyingTo$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+    /** Gets the NIP-10 replies to this event */
+    get replies$(): import("../observable/chainable.js").ChainableObservable<Note[]>;
+    /** 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 shares$(): import("../observable/chainable.js").ChainableObservable<Share[]>;
+    get reactions$(): import("../observable/chainable.js").ChainableObservable<Reaction[]>;
+}

package/dist/casts/note.js

@@ -0,0 +1,76 @@
+import { getEventPointerFromQTag, isQTag, kinds, processTags, } from "applesauce-core/helpers";
+import { getNip10References } from "../helpers/threading.js";
+import { CommentsModel } from "../models/comments.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { SharesModel } from "../models/shares.js";
+import { RepliesModel } from "../models/thread.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 { Share } from "./share.js";
+import { Zap } from "./zap.js";
+import { of } from "rxjs";
+function isValidNote(event) {
+    return event.kind === kinds.ShortTextNote;
+}
+export class Note extends EventCast {
+    constructor(event, store) {
+        if (!isValidNote(event))
+            throw new Error("Invalid note");
+        super(event, store);
+    }
+    get references() {
+        return getNip10References(this.event);
+    }
+    get isReply() {
+        return !!this.references.reply?.e || !!this.references.reply?.a;
+    }
+    get isRoot() {
+        return !this.references.reply && !this.references.root;
+    }
+    /** An array of events that this note is quoting */
+    get quotePointers() {
+        return processTags(this.event.tags, (t) => (isQTag(t) ? t : undefined), (t) => getEventPointerFromQTag(t) ?? undefined);
+    }
+    /** Gets the NIP-10 root event */
+    get threadRoot$() {
+        return this.$$ref("threadRoot$", (store) => {
+            const pointer = this.references.root;
+            // Return undefined if no root reference
+            if (pointer === undefined)
+                return of(undefined);
+            // Get the event by either the address or event pointer
+            return store.event(pointer.a ?? pointer.e);
+        });
+    }
+    /** Gets the NIP-10 reply event */
+    get replyingTo$() {
+        return this.$$ref("replyingTo$", (store) => {
+            const pointer = this.references.reply;
+            // Return undefined if no reply reference
+            if (pointer === undefined)
+                return of(undefined);
+            // Get the event by either the address or event pointer
+            return store.event(pointer.a ?? pointer.e);
+        });
+    }
+    /** Gets the NIP-10 replies to this event */
+    get replies$() {
+        return this.$$ref("replies$", (store) => store.model(RepliesModel, this.event, [kinds.ShortTextNote]).pipe(castTimelineStream(Note, store)));
+    }
+    /** 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 shares$() {
+        return this.$$ref("shares$", (store) => store.model(SharesModel, this.event).pipe(castTimelineStream(Share, store)));
+    }
+    get reactions$() {
+        return this.$$ref("reactions$", (store) => store.model(ReactionsModel, this.event).pipe(castTimelineStream(Reaction, store)));
+    }
+}

package/dist/casts/profile.d.ts

@@ -0,0 +1,24 @@
+import { NostrEvent, ProfileEvent } from "applesauce-core/helpers";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Cast a kind 0 event to a Profile */
+export declare class Profile extends EventCast<ProfileEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get metadata(): import("applesauce-core/helpers").ProfileContent;
+    get name(): string | undefined;
+    get displayName(): string | undefined;
+    get about(): string | undefined;
+    get picture(): string | undefined;
+    get banner(): string | undefined;
+    get dnsIdentity(): string | undefined;
+    get website(): string | undefined;
+    get lud16(): string | undefined;
+    get lud06(): string | undefined;
+    get lightningAddress(): string | undefined;
+    get bot(): boolean | undefined;
+    get birthday(): {
+        year?: number;
+        month?: number;
+        day?: number;
+    } | undefined;
+    get languages(): string[] | undefined;
+}

package/dist/casts/profile.js

@@ -0,0 +1,52 @@
+import { getDisplayName, getProfileContent, getProfilePicture, isValidProfile } from "applesauce-core/helpers/profile";
+import { EventCast } from "./cast.js";
+/** Cast a kind 0 event to a Profile */
+export class Profile extends EventCast {
+    constructor(event, store) {
+        if (!isValidProfile(event))
+            throw new Error("Invalid profile");
+        super(event, store);
+    }
+    get metadata() {
+        return getProfileContent(this.event);
+    }
+    get name() {
+        return this.metadata.name;
+    }
+    get displayName() {
+        return getDisplayName(this.metadata);
+    }
+    get about() {
+        return this.metadata.about;
+    }
+    get picture() {
+        return getProfilePicture(this.metadata);
+    }
+    get banner() {
+        return this.metadata.banner;
+    }
+    get dnsIdentity() {
+        return this.metadata.nip05;
+    }
+    get website() {
+        return this.metadata.website;
+    }
+    get lud16() {
+        return this.metadata.lud16;
+    }
+    get lud06() {
+        return this.metadata.lud06;
+    }
+    get lightningAddress() {
+        return this.metadata.lud16 || this.metadata.lud06;
+    }
+    get bot() {
+        return this.metadata.bot;
+    }
+    get birthday() {
+        return this.metadata.birthday;
+    }
+    get languages() {
+        return this.metadata.languages;
+    }
+}

package/dist/casts/reaction.d.ts

@@ -0,0 +1,17 @@
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { CastRefEventStore, EventCast } from "./cast.js";
+export declare class Reaction extends EventCast<KnownEvent<7>> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** Get the emoji content of the reaction (defaults to "+" if empty) */
+    get content(): string;
+    /** Get the custom emoji if this reaction uses a custom emoji */
+    get emoji(): import("../helpers/emoji.js").Emoji | undefined;
+    /** Get the event pointer for the event being reacted to */
+    get eventPointer(): import("nostr-tools/nip19").EventPointer | undefined;
+    /** Get the address pointer for the event being reacted to (for replaceable events) */
+    get addressPointer(): import("nostr-tools/nip19").AddressPointer | undefined;
+    /** Get the pointer (event or address) for the event being reacted to */
+    get pointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer | undefined;
+    /** Get the event that this reaction is reacting to */
+    get reactedTo$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+}

package/dist/casts/reaction.js

@@ -0,0 +1,46 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { of } from "rxjs";
+import { getReactionEmoji } from "../helpers/emoji.js";
+import { getReactionAddressPointer, getReactionEventPointer } from "../helpers/reaction.js";
+import { EventCast } from "./cast.js";
+import { addRelayHintsToPointer } from "applesauce-core/helpers";
+function isValidReaction(event) {
+    return event.kind === kinds.Reaction;
+}
+export class Reaction extends EventCast {
+    constructor(event, store) {
+        if (!isValidReaction(event))
+            throw new Error("Invalid reaction");
+        super(event, store);
+    }
+    /** Get the emoji content of the reaction (defaults to "+" if empty) */
+    get content() {
+        return this.event.content || "+";
+    }
+    /** Get the custom emoji if this reaction uses a custom emoji */
+    get emoji() {
+        return getReactionEmoji(this.event);
+    }
+    /** Get the event pointer for the event being reacted to */
+    get eventPointer() {
+        return getReactionEventPointer(this.event);
+    }
+    /** Get the address pointer for the event being reacted to (for replaceable events) */
+    get addressPointer() {
+        return getReactionAddressPointer(this.event);
+    }
+    /** Get the pointer (event or address) for the event being reacted to */
+    get pointer() {
+        return this.addressPointer || this.eventPointer;
+    }
+    /** Get the event that this reaction is reacting to */
+    get reactedTo$() {
+        return this.$$ref("reactedTo$", (store) => {
+            const pointer = this.pointer;
+            if (!pointer)
+                return of(undefined);
+            else
+                return store.event(addRelayHintsToPointer(pointer, this.seen));
+        });
+    }
+}

package/dist/casts/relay-discovery.d.ts

@@ -0,0 +1,29 @@
+import { NostrEvent } from "applesauce-core/helpers";
+import { RelayDiscoveryEvent } from "../helpers/relay-discovery.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Cast a kind 30166 event to a RelayDiscovery */
+export declare class RelayDiscovery extends EventCast<RelayDiscoveryEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** Gets the relay URL from this discovery event (from the `d` tag) */
+    get url(): string | undefined;
+    /** Gets the round-trip time (RTT) for opening the relay connection (in milliseconds) */
+    get rttOpen(): number | undefined;
+    /** Gets the round-trip time (RTT) for reading from the relay (in milliseconds) */
+    get rttRead(): number | undefined;
+    /** Gets the round-trip time (RTT) for writing to the relay (in milliseconds) */
+    get rttWrite(): number | undefined;
+    /** Gets the network type from this discovery event (clearnet, tor, i2p, loki) */
+    get networkType(): string | undefined;
+    /** Gets all relay attributes from this discovery event (from `W` tags) */
+    get attributes(): string[];
+    /** Gets all supported NIPs from this discovery event (from `N` tags) */
+    get supportedNIPs(): string[];
+    /** Gets all requirements from this discovery event (from `R` tags) */
+    get requirements(): string[];
+    /** Gets all topics from this discovery event (from `t` tags) */
+    get topics(): string[];
+    /** Gets all accepted and unaccepted kinds from this discovery event (from `k` tags) */
+    get acceptedKinds(): string[];
+    /** Gets the geohash from this discovery event (NIP-52 geohash) */
+    get geohash(): string | undefined;
+}

package/dist/casts/relay-discovery.js

@@ -0,0 +1,54 @@
+import { getRelayDiscoveryAcceptedKinds, getRelayDiscoveryAttributes, getRelayDiscoveryGeohash, getRelayDiscoveryNetworkType, getRelayDiscoveryRequirements, getRelayDiscoveryRTT, getRelayDiscoverySupportedNIPs, getRelayDiscoveryTopics, getRelayDiscoveryURL, isValidRelayDiscovery, } from "../helpers/relay-discovery.js";
+import { EventCast } from "./cast.js";
+/** Cast a kind 30166 event to a RelayDiscovery */
+export class RelayDiscovery extends EventCast {
+    constructor(event, store) {
+        if (!isValidRelayDiscovery(event))
+            throw new Error("Invalid relay discovery event");
+        super(event, store);
+    }
+    /** Gets the relay URL from this discovery event (from the `d` tag) */
+    get url() {
+        return getRelayDiscoveryURL(this.event);
+    }
+    /** Gets the round-trip time (RTT) for opening the relay connection (in milliseconds) */
+    get rttOpen() {
+        return getRelayDiscoveryRTT(this.event, "open");
+    }
+    /** Gets the round-trip time (RTT) for reading from the relay (in milliseconds) */
+    get rttRead() {
+        return getRelayDiscoveryRTT(this.event, "read");
+    }
+    /** Gets the round-trip time (RTT) for writing to the relay (in milliseconds) */
+    get rttWrite() {
+        return getRelayDiscoveryRTT(this.event, "write");
+    }
+    /** Gets the network type from this discovery event (clearnet, tor, i2p, loki) */
+    get networkType() {
+        return getRelayDiscoveryNetworkType(this.event);
+    }
+    /** Gets all relay attributes from this discovery event (from `W` tags) */
+    get attributes() {
+        return getRelayDiscoveryAttributes(this.event);
+    }
+    /** Gets all supported NIPs from this discovery event (from `N` tags) */
+    get supportedNIPs() {
+        return getRelayDiscoverySupportedNIPs(this.event);
+    }
+    /** Gets all requirements from this discovery event (from `R` tags) */
+    get requirements() {
+        return getRelayDiscoveryRequirements(this.event);
+    }
+    /** Gets all topics from this discovery event (from `t` tags) */
+    get topics() {
+        return getRelayDiscoveryTopics(this.event);
+    }
+    /** Gets all accepted and unaccepted kinds from this discovery event (from `k` tags) */
+    get acceptedKinds() {
+        return getRelayDiscoveryAcceptedKinds(this.event);
+    }
+    /** Gets the geohash from this discovery event (NIP-52 geohash) */
+    get geohash() {
+        return getRelayDiscoveryGeohash(this.event);
+    }
+}

package/dist/casts/relay-lists.d.ts

@@ -0,0 +1,33 @@
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { BlockedRelaysListEvent, FAVORITE_RELAYS_KIND, FavoriteRelaysListEvent, SearchRelaysListEvent } from "../helpers/relay-list.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Base class for relay lists */
+declare class RelayListBase<T extends KnownEvent<typeof FAVORITE_RELAYS_KIND | typeof kinds.SearchRelaysList | kinds.BlockedRelaysList>> extends EventCast<T> {
+    constructor(event: T, store: CastRefEventStore);
+    /** The public relays in the relay list */
+    get relays(): string[];
+    /** The hidden relays in the relay list */
+    get hidden(): string[];
+    /** An observable that updates when the hidden relays are unlocked */
+    get hidden$(): import("../observable/chainable.js").ChainableObservable<string[]>;
+    /** Whether the relay list has hidden relays */
+    get hasHidden(): boolean;
+    /** Whether the relay list is unlocked */
+    get unlocked(): boolean;
+    /** Unlocks the hidden relays on the relay list */
+    unlock(signer: HiddenContentSigner): Promise<string[]>;
+}
+/** Class for favorite relays lists (kind 10012) */
+export declare class FavoriteRelays extends RelayListBase<FavoriteRelaysListEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+}
+/** Class for search relays lists (kind 10007) */
+export declare class SearchRelays extends RelayListBase<SearchRelaysListEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+}
+/** Class for blocked relays lists (kind 10006) */
+export declare class BlockedRelays extends RelayListBase<BlockedRelaysListEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+}
+export {};

package/dist/casts/relay-lists.js

@@ -0,0 +1,72 @@
+import { defined, watchEventUpdates } from "applesauce-core";
+import { hasHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers";
+import { kinds } from "applesauce-core/helpers/event";
+import { map, of } from "rxjs";
+import { getRelaysFromList } from "../helpers/lists.js";
+import { FAVORITE_RELAYS_KIND, isValidBlockedRelaysList, isValidFavoriteRelaysList, isValidSearchRelaysList, } from "../helpers/relay-list.js";
+import { EventCast } from "./cast.js";
+/** Base class for relay lists */
+class RelayListBase extends EventCast {
+    constructor(event, store) {
+        if (event.kind !== FAVORITE_RELAYS_KIND &&
+            event.kind !== kinds.SearchRelaysList &&
+            event.kind !== kinds.BlockedRelaysList)
+            throw new Error(`Invalid relay list (kind ${event.kind})`);
+        super(event, store);
+    }
+    /** The public relays in the relay list */
+    get relays() {
+        return getRelaysFromList(this.event);
+    }
+    /** The hidden relays in the relay list */
+    get hidden() {
+        return getRelaysFromList(this.event, "hidden");
+    }
+    /** An observable that updates when the hidden relays are unlocked */
+    get hidden$() {
+        return this.$$ref("hidden$", (store) => of(this.event).pipe(
+        // Watch for event updates
+        watchEventUpdates(store), 
+        // Get the hidden relays
+        map((event) => event && getRelaysFromList(event, "hidden")), 
+        // Only emit when the hidden relays are unlocked
+        defined()));
+    }
+    /** Whether the relay list has hidden relays */
+    get hasHidden() {
+        return hasHiddenTags(this.event);
+    }
+    /** Whether the relay list is unlocked */
+    get unlocked() {
+        return isHiddenTagsUnlocked(this.event);
+    }
+    /** Unlocks the hidden relays on the relay list */
+    async unlock(signer) {
+        await unlockHiddenTags(this.event, signer);
+        return this.hidden;
+    }
+}
+/** Class for favorite relays lists (kind 10012) */
+export class FavoriteRelays extends RelayListBase {
+    constructor(event, store) {
+        if (!isValidFavoriteRelaysList(event))
+            throw new Error("Invalid favorite relays list");
+        super(event, store);
+    }
+}
+/** Class for search relays lists (kind 10007) */
+export class SearchRelays extends RelayListBase {
+    constructor(event, store) {
+        if (!isValidSearchRelaysList(event))
+            throw new Error("Invalid search relays list");
+        super(event, store);
+    }
+}
+/** Class for blocked relays lists (kind 10006) */
+export class BlockedRelays extends RelayListBase {
+    constructor(event, store) {
+        if (!isValidBlockedRelaysList(event))
+            throw new Error("Invalid blocked relays list");
+        super(event, store);
+    }
+}

package/dist/casts/relay-monitor.d.ts

@@ -0,0 +1,21 @@
+import { NostrEvent } from "applesauce-core/helpers";
+import { RelayMonitorAnnouncementEvent } from "../helpers/relay-discovery.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { RelayDiscovery } from "./relay-discovery.js";
+/** Cast a kind 10166 event to a RelayMonitor */
+export declare class RelayMonitor extends EventCast<RelayMonitorAnnouncementEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** Gets the frequency at which this monitor publishes events (in seconds) */
+    get frequency(): number | undefined;
+    /** Gets all timeout values from this monitor announcement */
+    get timeouts(): {
+        test?: string;
+        timeout: number;
+    }[];
+    /** Gets all checks conducted by this monitor */
+    get checks(): string[];
+    /** Gets the geohash from this monitor announcement (NIP-52 geohash) */
+    get geohash(): string | undefined;
+    /** Get the status of a relay from this monitor */
+    relayStatus(relay: string): import("../observable/chainable.js").ChainableObservable<RelayDiscovery | undefined>;
+}

package/dist/casts/relay-monitor.js

@@ -0,0 +1,41 @@
+import { switchMap } from "rxjs";
+import { getMonitorChecks, getMonitorFrequency, getMonitorGeohash, getMonitorTimeouts, isValidRelayMonitorAnnouncement, RELAY_DISCOVERY_KIND, } from "../helpers/relay-discovery.js";
+import { castEventStream } from "../observable/cast-stream.js";
+import { chainable } from "../observable/chainable.js";
+import { EventCast } from "./cast.js";
+import { RelayDiscovery } from "./relay-discovery.js";
+/** Cast a kind 10166 event to a RelayMonitor */
+export class RelayMonitor extends EventCast {
+    constructor(event, store) {
+        if (!isValidRelayMonitorAnnouncement(event))
+            throw new Error("Invalid relay monitor announcement");
+        super(event, store);
+    }
+    /** Gets the frequency at which this monitor publishes events (in seconds) */
+    get frequency() {
+        return getMonitorFrequency(this.event);
+    }
+    /** Gets all timeout values from this monitor announcement */
+    get timeouts() {
+        return getMonitorTimeouts(this.event);
+    }
+    /** Gets all checks conducted by this monitor */
+    get checks() {
+        return getMonitorChecks(this.event);
+    }
+    /** Gets the geohash from this monitor announcement (NIP-52 geohash) */
+    get geohash() {
+        return getMonitorGeohash(this.event);
+    }
+    /** Get the status of a relay from this monitor */
+    relayStatus(relay) {
+        return chainable(this.author.outboxes$.pipe(switchMap((outboxes) => this.store
+            .replaceable({
+            kind: RELAY_DISCOVERY_KIND,
+            pubkey: this.author.pubkey,
+            identifier: relay,
+            relays: outboxes,
+        })
+            .pipe(castEventStream(RelayDiscovery, this.store)))));
+    }
+}