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

package/dist/helpers/bookmark.d.ts

@@ -1,30 +1,31 @@
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
 import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+/** Type for a validated bookmark list event */
+export type BookmarkListEvent = KnownEvent<kinds.BookmarkList>;
+/** Type for a validated bookmark set event */
+export type BookmarkSetEvent = KnownEvent<kinds.Bookmarksets>;
+/** Validates that an event is a valid bookmark list (kind 10000) */
+export declare function isValidBookmarkList(event: NostrEvent): event is BookmarkListEvent;
+/** Validates that an event is a valid bookmark set (kind 30003) */
+export declare function isValidBookmarkSet(event: NostrEvent): event is BookmarkSetEvent;
 export declare const BookmarkPublicSymbol: unique symbol;
 export declare const BookmarkHiddenSymbol: unique symbol;
+export type BookmarkPointer = EventPointer | AddressPointer;
 /** Type for unlocked bookmarks events */
 export type UnlockedBookmarks = {
-    [BookmarkHiddenSymbol]: Bookmarks;
-};
-export type Bookmarks = {
-    notes: EventPointer[];
-    articles: AddressPointer[];
-    hashtags: string[];
-    urls: string[];
+    [BookmarkHiddenSymbol]: BookmarkPointer[];
 };
 /** Parses an array of tags into a {@link Bookmarks} object */
-export declare function parseBookmarkTags(tags: string[][]): Bookmarks;
+export declare function parseBookmarkTags(tags: string[][]): BookmarkPointer[];
 /** Merges any number of {@link Bookmarks} objects */
-export declare function mergeBookmarks(...bookmarks: (Bookmarks | undefined)[]): Bookmarks;
-/** Returns all the bookmarks of the event */
-export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
-/** Returns the public bookmarks of the event */
-export declare function getPublicBookmarks(bookmark: NostrEvent): Bookmarks;
+export declare function mergeBookmarks(...bookmarks: (BookmarkPointer[] | undefined)[]): BookmarkPointer[];
+/** Returns the bookmarks of the event */
+export declare function getBookmarks(bookmark: NostrEvent): BookmarkPointer[];
 /** Checks if the hidden bookmarks are unlocked */
 export declare function isHiddenBookmarksUnlocked<T extends NostrEvent>(bookmark: T): bookmark is T & UnlockedBookmarks;
 /** Returns the bookmarks of the event if its unlocked */
-export declare function getHiddenBookmarks<T extends NostrEvent & UnlockedBookmarks>(bookmark: T): Bookmarks;
-export declare function getHiddenBookmarks<T extends NostrEvent>(bookmark: T): Bookmarks | undefined;
+export declare function getHiddenBookmarks<T extends NostrEvent & UnlockedBookmarks>(bookmark: T): BookmarkPointer[];
+export declare function getHiddenBookmarks<T extends NostrEvent>(bookmark: T): BookmarkPointer[] | undefined;
 /** Unlocks the hidden bookmarks on a bookmarks event */
-export declare function unlockHiddenBookmarks(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<Bookmarks>;
+export declare function unlockHiddenBookmarks(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<BookmarkPointer[]>;

package/dist/helpers/bookmark.js

@@ -1,78 +1,65 @@
-import { getOrComputeCachedValue, notifyEventUpdate } from "applesauce-core/helpers";
+import { getOrComputeCachedValue, isATag, isETag, notifyEventUpdate, processTags } from "applesauce-core/helpers";
 import { kinds } from "applesauce-core/helpers/event";
 import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
-import { getAddressPointerFromATag, getReplaceableAddressFromPointer, getEventPointerFromETag, mergeAddressPointers, mergeEventPointers, } from "applesauce-core/helpers/pointers";
+import { getAddressPointerFromATag, getEventPointerFromETag, getReplaceableAddressFromPointer, isAddressPointer, isEventPointer, mergeAddressPointers, mergeEventPointers, } from "applesauce-core/helpers/pointers";
+/** Validates that an event is a valid bookmark list (kind 10000) */
+export function isValidBookmarkList(event) {
+    return event.kind === kinds.BookmarkList;
+}
+/** Validates that an event is a valid bookmark set (kind 30003) */
+export function isValidBookmarkSet(event) {
+    return event.kind === kinds.Bookmarksets;
+}
 export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
 export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
 /** Parses an array of tags into a {@link Bookmarks} object */
 export function parseBookmarkTags(tags) {
-    const notes = tags
-        .filter((t) => t[0] === "e" && t[1])
-        .map(getEventPointerFromETag)
-        .filter((pointer) => pointer !== null);
-    const articles = tags
-        .filter((t) => t[0] === "a" && t[1])
-        .map(getAddressPointerFromATag)
-        .filter((pointer) => pointer !== null)
-        .filter((pointer) => pointer.kind === kinds.LongFormArticle);
-    const hashtags = tags.filter((t) => t[0] === "t" && t[1]).map((t) => t[1]);
-    const urls = tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
-    return { notes, articles, hashtags, urls };
+    return processTags(tags, (t) => {
+        if (isETag(t))
+            return getEventPointerFromETag(t) ?? undefined;
+        if (isATag(t)) {
+            const pointer = getAddressPointerFromATag(t) ?? undefined;
+            // Ensure the address pointer is a long form article
+            if (pointer?.kind !== kinds.LongFormArticle)
+                return undefined;
+            return pointer;
+        }
+        return undefined;
+    });
 }
 /** Merges any number of {@link Bookmarks} objects */
 export function mergeBookmarks(...bookmarks) {
     const notes = new Map();
     const articles = new Map();
-    const hashtags = new Set();
-    const urls = new Set();
-    for (const bookmark of bookmarks) {
-        if (!bookmark)
-            continue;
-        for (const note of bookmark.notes) {
-            const existing = notes.get(note.id);
+    for (const pointer of bookmarks.flat()) {
+        if (isEventPointer(pointer)) {
+            const existing = notes.get(pointer.id);
             if (existing)
-                notes.set(note.id, mergeEventPointers(existing, note));
+                notes.set(pointer.id, mergeEventPointers(existing, pointer));
             else
-                notes.set(note.id, note);
+                notes.set(pointer.id, pointer);
         }
-        for (const article of bookmark.articles) {
-            const coord = getReplaceableAddressFromPointer(article);
-            const existing = articles.get(coord);
+        else if (isAddressPointer(pointer)) {
+            const address = getReplaceableAddressFromPointer(pointer);
+            const existing = articles.get(address);
             if (existing)
-                articles.set(coord, mergeAddressPointers(existing, article));
+                articles.set(address, mergeAddressPointers(existing, pointer));
             else
-                articles.set(coord, article);
+                articles.set(address, pointer);
         }
-        for (const hashtag of bookmark.hashtags)
-            hashtags.add(hashtag);
-        for (const url of bookmark.urls)
-            urls.add(url);
     }
-    return {
-        notes: Array.from(notes.values()),
-        articles: Array.from(articles.values()),
-        hashtags: Array.from(hashtags),
-        urls: Array.from(urls),
-    };
+    return [...notes.values(), ...articles.values()];
 }
-/** Returns all the bookmarks of the event */
+/** Returns the bookmarks of the event */
 export function getBookmarks(bookmark) {
-    const hidden = getHiddenBookmarks(bookmark);
-    if (hidden)
-        return mergeBookmarks(hidden, getPublicBookmarks(bookmark));
-    else
-        return getPublicBookmarks(bookmark);
-}
-/** Returns the public bookmarks of the event */
-export function getPublicBookmarks(bookmark) {
     return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
 }
 /** Checks if the hidden bookmarks are unlocked */
 export function isHiddenBookmarksUnlocked(bookmark) {
-    return isHiddenTagsUnlocked(bookmark) && Reflect.has(bookmark, BookmarkHiddenSymbol);
+    return (isHiddenTagsUnlocked(bookmark) && (BookmarkHiddenSymbol in bookmark || getHiddenBookmarks(bookmark) !== undefined));
 }
 export function getHiddenBookmarks(bookmark) {
-    if (isHiddenBookmarksUnlocked(bookmark))
+    if (BookmarkHiddenSymbol in bookmark)
         return bookmark[BookmarkHiddenSymbol];
     //get hidden tags
     const tags = getHiddenTags(bookmark);

package/dist/helpers/encrypted-content-cache.js

@@ -1,8 +1,8 @@
 import { logger } from "applesauce-core";
 import { canHaveEncryptedContent, getEncryptedContent, isEncryptedContentUnlocked, setEncryptedContentCache, } from "applesauce-core/helpers/encrypted-content";
 import { kinds, notifyEventUpdate } from "applesauce-core/helpers/event";
-import { catchError, combineLatest, distinct, EMPTY, filter, isObservable, map, merge, mergeMap, of, switchMap, } from "rxjs";
-import { getGiftWrapSeal, getSealGiftWrap, getSealRumor } from "./gift-wrap.js";
+import { catchError, combineLatest, combineLatestWith, distinct, EMPTY, filter, isObservable, map, merge, mergeMap, of, switchMap, } from "rxjs";
+import { getGiftWrapSeal, getSealGiftWrap, getSealRumor, isGiftWrapUnlocked } from "./gift-wrap.js";
 /** A symbol that is used to mark encrypted content as being from a cache */
 export const EncryptedContentFromCacheSymbol = Symbol.for("encrypted-content-from-cache");
 /** Marks the encrypted content as being from a cache */
@@ -32,15 +32,20 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
         .pipe(
     // Look for events that support encrypted content and are locked
     filter((e) => canHaveEncryptedContent(e.kind) && isEncryptedContentUnlocked(e) === false), 
+    // Get the storage
+    combineLatestWith(storage$), 
     // Get the encrypted content from storage
-    mergeMap((event) => 
-    // Wait for storage to be available
-    storage$.pipe(switchMap((storage) => combineLatest([of(event), getItem(storage, event)])), catchError((error) => {
-        log(`Failed to restore encrypted content for ${event.id}`, error);
-        return EMPTY;
-    }))))
+    mergeMap(([event, storage]) => 
+    // Get content from storage
+    combineLatest([
+        of(event),
+        getItem(storage, event).catch((error) => {
+            log(`Failed to restore encrypted content for ${event.id}`, error);
+            return of(null);
+        }),
+    ])))
         .subscribe(async ([event, content]) => {
-        if (!content)
+        if (typeof content !== "string")
             return;
         // Restore the encrypted content and set it as from a cache
         markEncryptedContentFromCache(event);
@@ -79,14 +84,16 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
         log(`Restored encrypted content for ${seal.id}`);
     });
     // Persist encrypted content when it is updated or inserted
-    const persist = combineLatest([merge(eventStore.update$, eventStore.insert$), storage$])
+    const persist = merge(eventStore.update$, eventStore.insert$)
         .pipe(
     // Look for events that support encrypted content and are unlocked and not from the cache
-    filter(([event]) => canHaveEncryptedContent(event.kind) &&
+    filter((event) => canHaveEncryptedContent(event.kind) &&
         isEncryptedContentUnlocked(event) &&
-        !isEncryptedContentFromCache(event)), 
+        isEncryptedContentFromCache(event) === false), 
     // Only persist the encrypted content once
-    distinct(([event]) => event.id))
+    distinct((event) => event.id), 
+    // get the storage
+    combineLatestWith(storage$))
         .subscribe(async ([event, storage]) => {
         try {
             const content = getEncryptedContent(event);
@@ -102,18 +109,9 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     });
     // Persist seals when the gift warp is unlocked or inserted unlocked
     // This relies on the gift wrap event being updated when a seal is unlocked
-    const persistSeals = combineLatest([merge(eventStore.update$, eventStore.insert$), storage$])
-        .pipe(
-    // Look for gift wraps that are unlocked
-    filter(([event]) => event.kind === kinds.GiftWrap && isEncryptedContentUnlocked(event)), 
-    // Get the seal event
-    map(([gift, storage]) => [getGiftWrapSeal(gift), storage]), 
-    // Make sure the seal is defined
-    filter(([seal]) => seal !== undefined), 
-    // Make sure seal is unlocked and not from cache
-    filter(([seal]) => isEncryptedContentUnlocked(seal) && !isEncryptedContentFromCache(seal)), 
-    // Only persist the seal once
-    distinct(([seal]) => seal.id))
+    const unlockedSeals$ = merge(eventStore.update$, eventStore.insert$).pipe(filter((event) => event.kind === kinds.GiftWrap), filter(isGiftWrapUnlocked), map((gift) => getGiftWrapSeal(gift)), distinct((seal) => seal.id));
+    const persistSeals = unlockedSeals$
+        .pipe(filter((seal) => isEncryptedContentFromCache(seal) === false), combineLatestWith(storage$))
         .subscribe(async ([seal, storage]) => {
         if (!seal)
             return;

package/dist/helpers/gift-wrap.js

@@ -1,4 +1,5 @@
 import { EventMemory } from "applesauce-core/event-store";
+import { safeParse } from "applesauce-core/helpers";
 import { getEncryptedContent, isEncryptedContentUnlocked, lockEncryptedContent, unlockEncryptedContent, } from "applesauce-core/helpers/encrypted-content";
 import { kinds, notifyEventUpdate, verifyWrappedEvent, } from "applesauce-core/helpers/event";
 /**
@@ -64,7 +65,7 @@ export function getRumorGiftWraps(rumor) {
 }
 /** Checks if a seal event is locked and casts it to the {@link UnlockedSeal} type */
 export function isSealUnlocked(seal) {
-    return isEncryptedContentUnlocked(seal) === true && Reflect.has(seal, RumorSymbol) === true;
+    return RumorSymbol in seal || (isEncryptedContentUnlocked(seal) === true && getSealRumor(seal) !== undefined);
 }
 /** Returns if a gift-wrap event or gift-wrap seal is locked */
 export function isGiftWrapUnlocked(gift) {
@@ -84,7 +85,7 @@ export function getSealRumor(seal) {
     if (seal.kind !== kinds.Seal)
         return undefined;
     // If unlocked return the rumor
-    if (isSealUnlocked(seal))
+    if (RumorSymbol in seal)
         return seal[RumorSymbol];
     // Get the encrypted content plaintext
     const content = getEncryptedContent(seal);
@@ -92,7 +93,12 @@ export function getSealRumor(seal) {
     if (!content)
         return undefined;
     // Parse the content as a rumor event
-    let rumor = JSON.parse(content);
+    let rumor = safeParse(content);
+    // Failed to parse rumor, save undefined and return undefined
+    if (!rumor) {
+        Reflect.set(seal, RumorSymbol, undefined);
+        return undefined;
+    }
     // Check if the rumor event already exists in the internal event set
     const existing = internalGiftWrapEvents.getEvent(rumor.id);
     if (existing)
@@ -112,8 +118,8 @@ export function getSealRumor(seal) {
 }
 export function getGiftWrapSeal(gift) {
     // Returned cached seal if it exists (downstream)
-    if (Reflect.has(gift, SealSymbol))
-        return Reflect.get(gift, SealSymbol);
+    if (SealSymbol in gift)
+        return gift[SealSymbol];
     // Get the encrypted content
     const content = getEncryptedContent(gift);
     // Return undefined if the content is not found

package/dist/helpers/groups.d.ts

@@ -1,7 +1,19 @@
 import { NostrEvent } from "applesauce-core/helpers/event";
-import { NameValueTag } from "applesauce-core/helpers/tags";
 export declare const GROUPS_LIST_KIND = 10009;
 export declare const GROUP_MESSAGE_KIND = 9;
+export declare const GROUP_METADATA_KIND = 39000;
+export declare const GROUP_ADMINS_KIND = 39001;
+export declare const GROUP_MEMBERS_KIND = 39002;
+export declare const GROUP_ROLES_KIND = 39003;
+export declare const JOIN_REQUEST_KIND = 9021;
+export declare const LEAVE_REQUEST_KIND = 9022;
+export declare const PUT_USER_KIND = 9000;
+export declare const REMOVE_USER_KIND = 9001;
+export declare const EDIT_METADATA_KIND = 9002;
+export declare const DELETE_EVENT_KIND = 9005;
+export declare const CREATE_GROUP_KIND = 9007;
+export declare const DELETE_GROUP_KIND = 9008;
+export declare const CREATE_INVITE_KIND = 9009;
 /** NIP-29 group pointer */
 export type GroupPointer = {
     /** the id of the group */
@@ -18,16 +30,116 @@ export declare function encodeGroupPointer(pointer: GroupPointer): string;
 export declare const GroupsPublicSymbol: unique symbol;
 export declare const GroupsHiddenSymbol: unique symbol;
 /** gets a {@link GroupPointer} from a "h" tag if it has a relay hint */
-export declare function getGroupPointerFromHTag(tag: string[]): GroupPointer | undefined;
+export declare function getGroupPointerFromHTag(tag: string[], hint?: string): GroupPointer | undefined;
 /** gets a {@link GroupPointer} from a "group" tag */
 export declare function getGroupPointerFromGroupTag(tag: string[]): GroupPointer;
 /** Returns all the public groups from a k:10009 list */
 export declare function getPublicGroups(bookmark: NostrEvent): GroupPointer[];
 /** Returns all the hidden groups from a k:10009 list */
 export declare function getHiddenGroups(bookmark: NostrEvent): GroupPointer[] | undefined;
+/** Gets a {@link GroupPointer} from a group event by reading the "h" tag */
+export declare function getGroupPointer(event: NostrEvent, relay?: string): GroupPointer | undefined;
+/** Gets the group id from a group event by reading the "h" tag */
+export declare function getGroupId(event: NostrEvent): string | undefined;
 /** Gets a {@link GroupPointer} from a kind 39000 group metadata event */
 export declare function getGroupPointerFromMetadata(event: NostrEvent, relay: string): GroupPointer | undefined;
-/** Creates a "h" tag for chat messages from a {@link GroupPointer} */
-export declare function createGroupHTagFromGroupPointer(group: GroupPointer): NameValueTag;
-/** Creates a "group" tag from a {@link GroupPointer} */
-export declare function createGroupTagFromGroupPointer(group: GroupPointer): NameValueTag;
+/** Group metadata structure from kind 39000 */
+export type GroupMetadata = {
+    id: string;
+    name?: string;
+    picture?: string;
+    about?: string;
+    isPublic: boolean;
+    isPrivate: boolean;
+    isOpen: boolean;
+    isClosed: boolean;
+};
+/** Group admin with roles from kind 39001 */
+export type GroupAdmin = {
+    pubkey: string;
+    roles: string[];
+};
+/** Group role definition from kind 39003 */
+export type GroupRole = {
+    name: string;
+    description?: string;
+};
+/** Join request event information (kind 9021) */
+export type GroupJoinRequestInfo = {
+    groupId: string;
+    reason?: string;
+    inviteCode?: string;
+};
+/** Leave request event information (kind 9022) */
+export type GroupLeaveRequestInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Put user event information (kind 9000) */
+export type GroupPutUserInfo = {
+    groupId: string;
+    pubkey: string;
+    roles?: string[];
+    reason?: string;
+};
+/** Remove user event information (kind 9001) */
+export type GroupRemoveUserInfo = {
+    groupId: string;
+    pubkey: string;
+    reason?: string;
+};
+/** Edit metadata event information (kind 9002) */
+export type GroupEditMetadataInfo = {
+    groupId: string;
+    metadataFields: Partial<GroupMetadata>;
+    reason?: string;
+};
+/** Delete event information (kind 9005) */
+export type GroupDeleteEventInfo = {
+    groupId: string;
+    eventId: string;
+    reason?: string;
+};
+/** Create group event information (kind 9007) */
+export type GroupCreateGroupInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Delete group event information (kind 9008) */
+export type GroupDeleteGroupInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Create invite event information (kind 9009) */
+export type GroupCreateInviteInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Gets group metadata from a kind 39000 event */
+export declare function getGroupMetadata(event: NostrEvent): GroupMetadata | undefined;
+/** Gets group admins from a kind 39001 event */
+export declare function getGroupAdmins(event: NostrEvent): GroupAdmin[] | undefined;
+/** Gets group members from a kind 39002 event */
+export declare function getGroupMembers(event: NostrEvent): string[] | undefined;
+/** Gets group roles from a kind 39003 event */
+export declare function getGroupRoles(event: NostrEvent): GroupRole[] | undefined;
+/** Gets join request information from a kind 9021 event */
+export declare function getGroupJoinRequestInfo(event: NostrEvent): GroupJoinRequestInfo | undefined;
+/** Gets leave request information from a kind 9022 event */
+export declare function getGroupLeaveRequestInfo(event: NostrEvent): GroupLeaveRequestInfo | undefined;
+/** Gets put user event information from a kind 9000 event */
+export declare function getGroupPutUserInfo(event: NostrEvent): GroupPutUserInfo | undefined;
+/** Gets remove user event information from a kind 9001 event */
+export declare function getGroupRemoveUserInfo(event: NostrEvent): GroupRemoveUserInfo | undefined;
+/** Gets edit metadata event information from a kind 9002 event */
+export declare function getGroupEditMetadataInfo(event: NostrEvent): GroupEditMetadataInfo | undefined;
+/** Gets delete event information from a kind 9005 event */
+export declare function getGroupDeleteEventInfo(event: NostrEvent): GroupDeleteEventInfo | undefined;
+/** Gets create group event information from a kind 9007 event */
+export declare function getGroupCreateGroupInfo(event: NostrEvent): GroupCreateGroupInfo | undefined;
+/** Gets delete group event information from a kind 9008 event */
+export declare function getGroupDeleteGroupInfo(event: NostrEvent): GroupDeleteGroupInfo | undefined;
+/** Gets create invite event information from a kind 9009 event */
+export declare function getGroupCreateInviteInfo(event: NostrEvent): GroupCreateInviteInfo | undefined;
+/** Checks group membership status from kind 9000/9001 events */
+export declare function checkGroupMembership(events: NostrEvent[], pubkey: string): boolean | undefined;