applesauce-common 0.0.0-next-20251209200210 → 0.0.0-next-20251220152312

package/dist/helpers/groups.js

@@ -1,10 +1,24 @@
 import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
 import { getReplaceableIdentifier, getTagValue } from "applesauce-core/helpers/event";
 import { getHiddenTags } from "applesauce-core/helpers/hidden-tags";
-import { fillAndTrimTag, processTags } from "applesauce-core/helpers/tags";
-import { ensureWebSocketURL, normalizeURL } from "applesauce-core/helpers/url";
+import { processTags } from "applesauce-core/helpers/tags";
+import { normalizeURL } from "applesauce-core/helpers/url";
 export const GROUPS_LIST_KIND = 10009;
 export const GROUP_MESSAGE_KIND = 9;
+// NIP-29 Group event kinds
+export const GROUP_METADATA_KIND = 39000;
+export const GROUP_ADMINS_KIND = 39001;
+export const GROUP_MEMBERS_KIND = 39002;
+export const GROUP_ROLES_KIND = 39003;
+export const JOIN_REQUEST_KIND = 9021;
+export const LEAVE_REQUEST_KIND = 9022;
+export const PUT_USER_KIND = 9000;
+export const REMOVE_USER_KIND = 9001;
+export const EDIT_METADATA_KIND = 9002;
+export const DELETE_EVENT_KIND = 9005;
+export const CREATE_GROUP_KIND = 9007;
+export const DELETE_GROUP_KIND = 9008;
+export const CREATE_INVITE_KIND = 9009;
 /** decodes a group identifier into a group pointer object */
 export function decodeGroupPointer(str) {
     let [relay, id] = str.split("'");
@@ -25,8 +39,10 @@ export function encodeGroupPointer(pointer) {
 export const GroupsPublicSymbol = Symbol.for("groups-public");
 export const GroupsHiddenSymbol = Symbol.for("groups-hidden");
 /** gets a {@link GroupPointer} from a "h" tag if it has a relay hint */
-export function getGroupPointerFromHTag(tag) {
-    const [_, id, relay] = tag;
+export function getGroupPointerFromHTag(tag, hint) {
+    let [_, id, relay] = tag;
+    if (!relay && hint)
+        relay = hint;
     if (!id || !relay)
         return undefined;
     return { id, relay };
@@ -48,6 +64,20 @@ export function getHiddenGroups(bookmark) {
             processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
     });
 }
+/** Gets a {@link GroupPointer} from a group event by reading the "h" tag */
+export function getGroupPointer(event, relay) {
+    const hTag = event.tags.find((t) => t[0] === "h");
+    if (!hTag)
+        return undefined;
+    return getGroupPointerFromHTag(hTag, relay);
+}
+/** Gets the group id from a group event by reading the "h" tag */
+export function getGroupId(event) {
+    const hTag = event.tags.find((t) => t[0] === "h");
+    if (!hTag)
+        return undefined;
+    return hTag[1];
+}
 /** Gets a {@link GroupPointer} from a kind 39000 group metadata event */
 export function getGroupPointerFromMetadata(event, relay) {
     // Use the "d" tag for the group ID and the provided relay
@@ -59,11 +89,258 @@ export function getGroupPointerFromMetadata(event, relay) {
         name: name,
     };
 }
-/** Creates a "h" tag for chat messages from a {@link GroupPointer} */
-export function createGroupHTagFromGroupPointer(group) {
-    return fillAndTrimTag(["h", group.id, ensureWebSocketURL(group.relay)]);
+// Symbols for caching parsed data
+const GroupMetadataSymbol = Symbol.for("group-metadata");
+const GroupAdminsSymbol = Symbol.for("group-admins");
+const GroupMembersSymbol = Symbol.for("group-members");
+const GroupRolesSymbol = Symbol.for("group-roles");
+const JoinRequestSymbol = Symbol.for("join-request");
+const LeaveRequestSymbol = Symbol.for("leave-request");
+const PutUserSymbol = Symbol.for("put-user");
+const RemoveUserSymbol = Symbol.for("remove-user");
+const EditMetadataSymbol = Symbol.for("edit-metadata");
+const DeleteEventSymbol = Symbol.for("delete-event");
+const CreateGroupSymbol = Symbol.for("create-group");
+const DeleteGroupSymbol = Symbol.for("delete-group");
+const CreateInviteSymbol = Symbol.for("create-invite");
+/** Gets group metadata from a kind 39000 event */
+export function getGroupMetadata(event) {
+    if (event.kind !== GROUP_METADATA_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupMetadataSymbol, () => {
+        const id = getReplaceableIdentifier(event) || "_";
+        const name = getTagValue(event, "name");
+        const picture = getTagValue(event, "picture");
+        const about = getTagValue(event, "about");
+        const publicTag = event.tags.find((t) => t[0] === "public");
+        const privateTag = event.tags.find((t) => t[0] === "private");
+        const openTag = event.tags.find((t) => t[0] === "open");
+        const closedTag = event.tags.find((t) => t[0] === "closed");
+        return {
+            id,
+            name,
+            picture,
+            about,
+            isPublic: !!publicTag,
+            isPrivate: !!privateTag,
+            isOpen: !!openTag,
+            isClosed: !!closedTag,
+        };
+    });
+}
+/** Gets group admins from a kind 39001 event */
+export function getGroupAdmins(event) {
+    if (event.kind !== GROUP_ADMINS_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupAdminsSymbol, () => {
+        const adminsMap = new Map();
+        for (const tag of event.tags) {
+            if (tag[0] === "p" && tag[1]) {
+                const pubkey = tag[1];
+                const roles = tag.slice(2).filter((r) => r.length > 0);
+                if (adminsMap.has(pubkey)) {
+                    const existingRoles = adminsMap.get(pubkey);
+                    adminsMap.set(pubkey, [...new Set([...existingRoles, ...roles])]);
+                }
+                else {
+                    adminsMap.set(pubkey, roles);
+                }
+            }
+        }
+        return Array.from(adminsMap.entries()).map(([pubkey, roles]) => ({
+            pubkey,
+            roles,
+        }));
+    });
+}
+/** Gets group members from a kind 39002 event */
+export function getGroupMembers(event) {
+    if (event.kind !== GROUP_MEMBERS_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupMembersSymbol, () => {
+        return event.tags.filter((t) => t[0] === "p" && t[1]).map((t) => t[1]);
+    });
+}
+/** Gets group roles from a kind 39003 event */
+export function getGroupRoles(event) {
+    if (event.kind !== GROUP_ROLES_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupRolesSymbol, () => {
+        return event.tags
+            .filter((t) => t[0] === "role" && t[1])
+            .map((t) => ({
+            name: t[1],
+            description: t[2],
+        }));
+    });
 }
-/** Creates a "group" tag from a {@link GroupPointer} */
-export function createGroupTagFromGroupPointer(group) {
-    return fillAndTrimTag(["group", group.id, ensureWebSocketURL(group.relay), group.name], 3);
+/** Gets join request information from a kind 9021 event */
+export function getGroupJoinRequestInfo(event) {
+    if (event.kind !== JOIN_REQUEST_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, JoinRequestSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+            inviteCode: getTagValue(event, "code"),
+        };
+    });
+}
+/** Gets leave request information from a kind 9022 event */
+export function getGroupLeaveRequestInfo(event) {
+    if (event.kind !== LEAVE_REQUEST_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, LeaveRequestSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets put user event information from a kind 9000 event */
+export function getGroupPutUserInfo(event) {
+    if (event.kind !== PUT_USER_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, PutUserSymbol, () => {
+        const groupId = getGroupId(event);
+        const pubkey = getTagValue(event, "p");
+        if (!groupId || !pubkey)
+            return undefined;
+        const roles = event.tags.filter((t) => t[0] === "p" && t.length > 2).flatMap((t) => t.slice(2));
+        return {
+            groupId,
+            pubkey,
+            roles: roles.length > 0 ? roles : undefined,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets remove user event information from a kind 9001 event */
+export function getGroupRemoveUserInfo(event) {
+    if (event.kind !== REMOVE_USER_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, RemoveUserSymbol, () => {
+        const groupId = getGroupId(event);
+        const pubkey = getTagValue(event, "p");
+        if (!groupId || !pubkey)
+            return undefined;
+        return {
+            groupId,
+            pubkey,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets edit metadata event information from a kind 9002 event */
+export function getGroupEditMetadataInfo(event) {
+    if (event.kind !== EDIT_METADATA_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, EditMetadataSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        const metadataFields = {};
+        const name = getTagValue(event, "name");
+        const picture = getTagValue(event, "picture");
+        const about = getTagValue(event, "about");
+        const publicTag = event.tags.find((t) => t[0] === "public");
+        const privateTag = event.tags.find((t) => t[0] === "private");
+        const openTag = event.tags.find((t) => t[0] === "open");
+        const closedTag = event.tags.find((t) => t[0] === "closed");
+        if (name !== undefined)
+            metadataFields.name = name;
+        if (picture !== undefined)
+            metadataFields.picture = picture;
+        if (about !== undefined)
+            metadataFields.about = about;
+        if (publicTag)
+            metadataFields.isPublic = true;
+        if (privateTag)
+            metadataFields.isPrivate = true;
+        if (openTag)
+            metadataFields.isOpen = true;
+        if (closedTag)
+            metadataFields.isClosed = true;
+        return {
+            groupId,
+            metadataFields,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets delete event information from a kind 9005 event */
+export function getGroupDeleteEventInfo(event) {
+    if (event.kind !== DELETE_EVENT_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, DeleteEventSymbol, () => {
+        const groupId = getGroupId(event);
+        const eventId = getTagValue(event, "e");
+        if (!groupId || !eventId)
+            return undefined;
+        return {
+            groupId,
+            eventId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets create group event information from a kind 9007 event */
+export function getGroupCreateGroupInfo(event) {
+    if (event.kind !== CREATE_GROUP_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, CreateGroupSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets delete group event information from a kind 9008 event */
+export function getGroupDeleteGroupInfo(event) {
+    if (event.kind !== DELETE_GROUP_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, DeleteGroupSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets create invite event information from a kind 9009 event */
+export function getGroupCreateInviteInfo(event) {
+    if (event.kind !== CREATE_INVITE_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, CreateInviteSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Checks group membership status from kind 9000/9001 events */
+export function checkGroupMembership(events, pubkey) {
+    // Filter to only membership-related events
+    const membershipEvents = events.filter((e) => (e.kind === PUT_USER_KIND || e.kind === REMOVE_USER_KIND) && getTagValue(e, "p") === pubkey);
+    if (membershipEvents.length === 0)
+        return undefined;
+    // Sort by created_at descending to get the latest event
+    const sorted = membershipEvents.sort((a, b) => b.created_at - a.created_at);
+    const latest = sorted[0];
+    // Latest event determines membership status
+    return latest.kind === PUT_USER_KIND;
 }

package/dist/helpers/index.d.ts

@@ -19,7 +19,6 @@ export * from "./highlight.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
 export * from "./lnurl.js";
-export * from "./mailboxes.js";
 export * from "./messages.js";
 export * from "./mute.js";
 export * from "./picture-post.js";
@@ -35,3 +34,4 @@ export * from "./torrent.js";
 export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zap.js";
+export * from "./relay-list.js";

package/dist/helpers/index.js

@@ -19,7 +19,6 @@ export * from "./highlight.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
 export * from "./lnurl.js";
-export * from "./mailboxes.js";
 export * from "./messages.js";
 export * from "./mute.js";
 export * from "./picture-post.js";
@@ -35,3 +34,4 @@ export * from "./torrent.js";
 export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zap.js";
+export * from "./relay-list.js";

package/dist/helpers/lists.d.ts

@@ -1,6 +1,5 @@
 import { NostrEvent } from "applesauce-core/helpers/event";
 import { AddressPointer, EventPointer, ProfilePointer } from "applesauce-core/helpers/pointers";
-export declare const FAVORITE_RELAYS_KIND = 10012;
 export type ReadListTags = "public" | "hidden" | "all";
 /** Returns all the tags of a list or set */
 export declare function getListTags(list: NostrEvent, type?: ReadListTags): string[][];

package/dist/helpers/lists.js

@@ -1,17 +1,16 @@
 import { getReplaceableIdentifier, isAddressableKind, isReplaceable, isReplaceableKind, } from "applesauce-core/helpers/event";
 import { getHiddenTags } from "applesauce-core/helpers/hidden-tags";
-import { getAddressPointerForEvent, getAddressPointerFromATag, getReplaceableAddressFromPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "applesauce-core/helpers/pointers";
-import { mergeRelaySets } from "applesauce-core/helpers/relays";
+import { getAddressPointerForEvent, getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag, getReplaceableAddressFromPointer, } from "applesauce-core/helpers/pointers";
+import { relaySet } from "applesauce-core/helpers/relays";
 import { isATag, isETag, isPTag, processTags } from "applesauce-core/helpers/tags";
-export const FAVORITE_RELAYS_KIND = 10012;
 /** Returns all the tags of a list or set */
 export function getListTags(list, type) {
     switch (type) {
+        default:
         case "public":
             return list.tags;
         case "hidden":
             return getHiddenTags(list) ?? [];
-        default:
         case "all":
             return [...(getHiddenTags(list) ?? []), ...list.tags];
     }
@@ -91,7 +90,7 @@ export function getProfilePointersFromList(list, type) {
  * @param type - Which types of tags to read
  */
 export function getRelaysFromList(list, type) {
-    return mergeRelaySets(processTags(getListTags(list, type), (t) => (t[0] === "relay" ? t[1] : undefined)));
+    return relaySet(processTags(getListTags(list, type), (t) => (t[0] === "relay" ? t[1] : undefined)));
 }
 /** Returns if an event is a valid list or set */
 export function isValidList(event) {

package/dist/helpers/mute.d.ts

@@ -1,33 +1,36 @@
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
+export type MuteListEvent = KnownEvent<typeof kinds.Mutelist>;
+/** Validates that an event is a valid mute list */
+export declare function isValidMuteList(event: NostrEvent): event is MuteListEvent;
 export declare const MutePublicSymbol: unique symbol;
 export declare const MuteHiddenSymbol: unique symbol;
 /** Type for unlocked mute events */
 export type UnlockedMutes = {
-    [MuteHiddenSymbol]: Mutes;
+    [MuteHiddenSymbol]: MutedThings;
 };
-export type Mutes = {
+export type MutedThings = {
     pubkeys: Set<string>;
     threads: Set<string>;
     hashtags: Set<string>;
     words: Set<string>;
 };
 /** Merges any number of mute sets */
-export declare function mergeMutes(...mutes: Mutes[]): Mutes;
+export declare function mergeMutes(...mutes: MutedThings[]): MutedThings;
 /** Parses mute tags */
-export declare function parseMutedTags(tags: string[][]): Mutes;
+export declare function parseMutedTags(tags: string[][]): MutedThings;
 /** Returns muted things */
-export declare function getMutedThings(mute: NostrEvent): Mutes;
+export declare function getMutedThings(mute: NostrEvent): MutedThings;
 /** Returns only the public muted things from a mute event */
-export declare function getPublicMutedThings(mute: NostrEvent): Mutes;
+export declare function getPublicMutedThings(mute: NostrEvent): MutedThings;
 /** Checks if the hidden mutes are unlocked */
 export declare function isHiddenMutesUnlocked<T extends NostrEvent>(mute: T): mute is T & UnlockedMutes;
 /** Returns the hidden muted content if the event is unlocked */
-export declare function getHiddenMutedThings<T extends NostrEvent & UnlockedMutes>(mute: T): Mutes;
-export declare function getHiddenMutedThings<T extends NostrEvent>(mute: T): Mutes | undefined;
+export declare function getHiddenMutedThings<T extends NostrEvent & UnlockedMutes>(mute: T): MutedThings;
+export declare function getHiddenMutedThings<T extends NostrEvent>(mute: T): MutedThings | undefined;
 /** Unlocks the hidden mutes */
-export declare function unlockHiddenMutes(mute: NostrEvent, signer: HiddenContentSigner): Promise<Mutes>;
+export declare function unlockHiddenMutes(mute: NostrEvent, signer: HiddenContentSigner): Promise<MutedThings>;
 /** Creates a RegExp for matching muted words */
 export declare function createMutedWordsRegExp(mutedWords: string[]): RegExp;
 /** Returns true if the event matches the mutes */
-export declare function matchMutes(mutes: Mutes, event: NostrEvent): boolean;
+export declare function matchMutes(mutes: MutedThings, event: NostrEvent): boolean;

package/dist/helpers/mute.js

@@ -1,9 +1,13 @@
 import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
 import { kinds, notifyEventUpdate } from "applesauce-core/helpers/event";
-import { isETag, isPTag, isTTag } from "applesauce-core/helpers/tags";
 import { getIndexableTags } from "applesauce-core/helpers/filter";
+import { isETag, isPTag, isTTag } from "applesauce-core/helpers/tags";
 import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
 import { getNip10References } from "./threading.js";
+/** Validates that an event is a valid mute list */
+export function isValidMuteList(event) {
+    return event.kind === kinds.Mutelist;
+}
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
 /** Merges any number of mute sets */
@@ -43,10 +47,11 @@ export function getPublicMutedThings(mute) {
 }
 /** Checks if the hidden mutes are unlocked */
 export function isHiddenMutesUnlocked(mute) {
-    return isHiddenTagsUnlocked(mute) && Reflect.has(mute, MuteHiddenSymbol);
+    // No need for try catch or proactivly parsing here since it only depends on hidden tags
+    return MuteHiddenSymbol in mute || isHiddenTagsUnlocked(mute);
 }
 export function getHiddenMutedThings(mute) {
-    if (isHiddenMutesUnlocked(mute))
+    if (MuteHiddenSymbol in mute)
         return mute[MuteHiddenSymbol];
     // get hidden tags
     const tags = getHiddenTags(mute);
@@ -60,7 +65,7 @@ export function getHiddenMutedThings(mute) {
 }
 /** Unlocks the hidden mutes */
 export async function unlockHiddenMutes(mute, signer) {
-    if (isHiddenMutesUnlocked(mute))
+    if (MuteHiddenSymbol in mute)
         return mute[MuteHiddenSymbol];
     // Unlock hidden tags
     await unlockHiddenTags(mute, signer);

package/dist/helpers/relay-list.d.ts

@@ -0,0 +1,14 @@
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+export declare const FAVORITE_RELAYS_KIND = 10012;
+export type FavoriteRelaysListEvent = KnownEvent<typeof FAVORITE_RELAYS_KIND>;
+export type SearchRelaysListEvent = KnownEvent<typeof kinds.SearchRelaysList>;
+export type BlockedRelaysListEvent = KnownEvent<typeof kinds.BlockedRelaysList>;
+export type DMRelaysListEvent = KnownEvent<typeof kinds.DirectMessageRelaysList>;
+/** Validates that an event is a valid favorite relays list (kind 10012) */
+export declare function isValidFavoriteRelaysList(event: NostrEvent): event is FavoriteRelaysListEvent;
+/** Validates that an event is a valid search relays list (kind 10007) */
+export declare function isValidSearchRelaysList(event: NostrEvent): event is SearchRelaysListEvent;
+/** Validates that an event is a valid blocked relays list (kind 10006) */
+export declare function isValidBlockedRelaysList(event: NostrEvent): event is BlockedRelaysListEvent;
+/** Validates that an event is a valid DM relays list (kind 10050) */
+export declare function isValidDirectMessageRelaysList(event: NostrEvent): event is DMRelaysListEvent;

package/dist/helpers/relay-list.js

@@ -0,0 +1,18 @@
+import { kinds } from "applesauce-core/helpers/event";
+export const FAVORITE_RELAYS_KIND = 10012;
+/** Validates that an event is a valid favorite relays list (kind 10012) */
+export function isValidFavoriteRelaysList(event) {
+    return event.kind === FAVORITE_RELAYS_KIND;
+}
+/** Validates that an event is a valid search relays list (kind 10007) */
+export function isValidSearchRelaysList(event) {
+    return event.kind === kinds.SearchRelaysList;
+}
+/** Validates that an event is a valid blocked relays list (kind 10006) */
+export function isValidBlockedRelaysList(event) {
+    return event.kind === kinds.BlockedRelaysList;
+}
+/** Validates that an event is a valid DM relays list (kind 10050) */
+export function isValidDirectMessageRelaysList(event) {
+    return event.kind === kinds.DirectMessageRelaysList;
+}

package/dist/helpers/stream-chat.d.ts

@@ -1,4 +1,7 @@
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { AddressPointer } from "applesauce-core/helpers/pointers";
+export type StreamChatMessageEvent = KnownEvent<kinds.LiveChatMessage>;
+export declare function isValidStreamChatMessage(event: NostrEvent): event is StreamChatMessageEvent;
 /** Returns the pointer to the stream chat message stream */
+export declare function getStreamChatMessageStream(message: StreamChatMessageEvent): AddressPointer;
 export declare function getStreamChatMessageStream(message: NostrEvent): AddressPointer | undefined;

package/dist/helpers/stream-chat.js

@@ -1,6 +1,9 @@
+import { kinds } from "applesauce-core/helpers/event";
 import { getAddressPointerFromATag } from "applesauce-core/helpers/pointers";
 import { isATag } from "applesauce-core/helpers/tags";
-/** Returns the pointer to the stream chat message stream */
+export function isValidStreamChatMessage(event) {
+    return event.kind === kinds.LiveChatMessage && getStreamChatMessageStream(event) !== undefined;
+}
 export function getStreamChatMessageStream(message) {
     const tag = message.tags.find(isATag);
     if (!tag)

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";
 export * as Blueprints from "./blueprints/index.js";
 export * as Observable from "./observable/index.js";
+export * as Casts from "./casts/index.js";
 import "./register.js";

package/dist/index.js

@@ -3,5 +3,6 @@ export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";
 export * as Blueprints from "./blueprints/index.js";
 export * as Observable from "./observable/index.js";
+export * as Casts from "./casts/index.js";
 // Register the common models and blueprints with the event store and event factory
 import "./register.js";

package/dist/models/__register__.d.ts

@@ -0,0 +1,5 @@
+import "./blossom.js";
+import "./mutes.js";
+import "./reactions.js";
+import "./comments.js";
+import "./thread.js";

package/dist/models/__register__.js

@@ -0,0 +1,6 @@
+// Import models that should register with the event store
+import "./blossom.js";
+import "./mutes.js";
+import "./reactions.js";
+import "./comments.js";
+import "./thread.js";

package/dist/models/bookmarks.d.ts

@@ -1,8 +1,6 @@
 import { Model } from "applesauce-core/event-store";
-import { Bookmarks } from "../helpers/bookmark.js";
+import { BookmarkPointer } from "../helpers/bookmark.js";
 /** A model that returns all the bookmarks of a user */
-export declare function UserBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
-/** A model that returns all the public bookmarks of a user */
-export declare function UserPublicBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
+export declare function UserBookmarkModel(pubkey: string): Model<BookmarkPointer[] | undefined>;
 /** A model that returns all the hidden bookmarks of a user */
-export declare function UserHiddenBookmarkModel(pubkey: string): Model<Bookmarks | null | undefined>;
+export declare function UserHiddenBookmarkModel(pubkey: string): Model<BookmarkPointer[] | null | undefined>;

package/dist/models/bookmarks.js

@@ -1,18 +1,10 @@
 import { kinds } from "applesauce-core/helpers/event";
 import { watchEventUpdates } from "applesauce-core/observable";
 import { map } from "rxjs/operators";
-import { getBookmarks, getHiddenBookmarks, getPublicBookmarks } from "../helpers/bookmark.js";
+import { getBookmarks, getHiddenBookmarks } from "../helpers/bookmark.js";
 /** A model that returns all the bookmarks of a user */
 export function UserBookmarkModel(pubkey) {
-    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
-    // listen for event updates (hidden tags unlocked)
-    watchEventUpdates(events), 
-    // Get all bookmarks
-    map((event) => event && getBookmarks(event)));
-}
-/** A model that returns all the public bookmarks of a user */
-export function UserPublicBookmarkModel(pubkey) {
-    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicBookmarks(event)));
+    return (events) => events.replaceable(kinds.BookmarkList, pubkey).pipe(map((event) => event && getBookmarks(event)));
 }
 /** A model that returns all the hidden bookmarks of a user */
 export function UserHiddenBookmarkModel(pubkey) {

package/dist/models/index.d.ts

@@ -12,6 +12,8 @@ export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
 export * from "./gift-wrap.js";
-export * from "./relays.js";
+export * from "./relay-lists.js";
 export * from "./stream.js";
+export * from "./shares.js";
+export * from "applesauce-core/models";
 import "../register.js";

package/dist/models/index.js

@@ -12,7 +12,10 @@ export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zaps.js";
 export * from "./gift-wrap.js";
-export * from "./relays.js";
+export * from "./relay-lists.js";
 export * from "./stream.js";
+export * from "./shares.js";
+// Export all models from core
+export * from "applesauce-core/models";
 // Register the common models with the event store
 import "../register.js";

package/dist/models/mutes.d.ts

@@ -1,16 +1,16 @@
 import { Model } from "applesauce-core/event-store";
 import { ProfilePointer } from "applesauce-core/helpers/pointers";
 import { type Observable } from "rxjs";
-import { Mutes } from "../helpers/mute.js";
+import { MutedThings } from "../helpers/mute.js";
 /** A model that returns all a users muted things */
-export declare function MuteModel(user: string | ProfilePointer): Model<Mutes | undefined>;
+export declare function MuteModel(user: string | ProfilePointer): Model<MutedThings | undefined>;
 /** A model that returns all a users public muted things */
-export declare function PublicMuteModel(pubkey: string): Model<Mutes | undefined>;
+export declare function PublicMuteModel(pubkey: string): Model<MutedThings | undefined>;
 /** A model that returns all a users hidden muted things */
-export declare function HiddenMuteModel(pubkey: string): Model<Mutes | null | undefined>;
+export declare function HiddenMuteModel(pubkey: string): Model<MutedThings | null | undefined>;
 declare module "applesauce-core/event-store" {
     interface EventModels {
         /** Subscribe to a users mutes */
-        mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
+        mutes(user: string | ProfilePointer): Observable<MutedThings | undefined>;
     }
 }