applesauce-common 0.0.0-next-20251220152312 → 0.0.0-next-20251231055351

package/dist/helpers/groups.d.ts

@@ -1,4 +1,5 @@
 import { NostrEvent } from "applesauce-core/helpers/event";
+import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
 export declare const GROUPS_LIST_KIND = 10009;
 export declare const GROUP_MESSAGE_KIND = 9;
 export declare const GROUP_METADATA_KIND = 39000;
@@ -35,8 +36,17 @@ export declare function getGroupPointerFromHTag(tag: string[], hint?: string): G
 export declare function getGroupPointerFromGroupTag(tag: string[]): GroupPointer;
 /** Returns all the public groups from a k:10009 list */
 export declare function getPublicGroups(bookmark: NostrEvent): GroupPointer[];
+/** Type for unlocked groups */
+export type UnlockedGroups = {
+    [GroupsHiddenSymbol]: GroupPointer[];
+};
 /** Returns all the hidden groups from a k:10009 list */
-export declare function getHiddenGroups(bookmark: NostrEvent): GroupPointer[] | undefined;
+export declare function getHiddenGroups<T extends NostrEvent & UnlockedGroups>(bookmark: T): GroupPointer[];
+export declare function getHiddenGroups<T extends NostrEvent>(bookmark: T): GroupPointer[] | undefined;
+/** Checks if the hidden groups are unlocked */
+export declare function isHiddenGroupsUnlocked<T extends NostrEvent>(bookmark: T): bookmark is T & UnlockedGroups;
+/** Unlocks the hidden groups on a groups event */
+export declare function unlockHiddenGroups(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<GroupPointer[]>;
 /** 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 */

package/dist/helpers/groups.js

@@ -1,6 +1,6 @@
-import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getOrComputeCachedValue, notifyEventUpdate } from "applesauce-core/helpers";
 import { getReplaceableIdentifier, getTagValue } from "applesauce-core/helpers/event";
-import { getHiddenTags } from "applesauce-core/helpers/hidden-tags";
+import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
 import { processTags } from "applesauce-core/helpers/tags";
 import { normalizeURL } from "applesauce-core/helpers/url";
 export const GROUPS_LIST_KIND = 10009;
@@ -56,14 +56,39 @@ export function getGroupPointerFromGroupTag(tag) {
 export function getPublicGroups(bookmark) {
     return getOrComputeCachedValue(bookmark, GroupsPublicSymbol, () => processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
 }
-/** Returns all the hidden groups from a k:10009 list */
 export function getHiddenGroups(bookmark) {
+    if (GroupsHiddenSymbol in bookmark)
+        return bookmark[GroupsHiddenSymbol];
     return getOrComputeCachedValue(bookmark, GroupsHiddenSymbol, () => {
+        //get hidden tags
         const tags = getHiddenTags(bookmark);
-        return (tags &&
-            processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+        if (!tags)
+            return undefined;
+        // parse groups from hidden tags
+        const groups = processTags(tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag);
+        // set cached value
+        Reflect.set(bookmark, GroupsHiddenSymbol, groups);
+        return groups;
     });
 }
+/** Checks if the hidden groups are unlocked */
+export function isHiddenGroupsUnlocked(bookmark) {
+    return isHiddenTagsUnlocked(bookmark) && (GroupsHiddenSymbol in bookmark || getHiddenGroups(bookmark) !== undefined);
+}
+/** Unlocks the hidden groups on a groups event */
+export async function unlockHiddenGroups(bookmark, signer) {
+    if (isHiddenGroupsUnlocked(bookmark))
+        return bookmark[GroupsHiddenSymbol];
+    // unlock hidden tags
+    await unlockHiddenTags(bookmark, signer);
+    // get hidden groups
+    const groups = getHiddenGroups(bookmark);
+    if (!groups)
+        throw new Error("Failed to unlock hidden groups");
+    // notify event store
+    notifyEventUpdate(bookmark);
+    return groups;
+}
 /** 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");

package/dist/helpers/reports.d.ts

@@ -14,6 +14,7 @@ export type ReportedUser = {
     event: NostrEvent;
     pubkey: string;
     reason?: ReportReason;
+    comment?: string;
 };
 export type ReportedEvent = {
     type: "event";
@@ -25,4 +26,6 @@ export type ReportedEvent = {
     blobs?: string[];
 };
 /** Reads a report event as either a user or event report */
-export declare function getReported(report: NostrEvent): ReportedEvent | ReportedUser;
+export declare function getReported(report: NostrEvent): ReportedEvent | ReportedUser | null;
+/** Gets the server tags from a report event (for blob reports) */
+export declare function getReportServers(report: NostrEvent): string[];

package/dist/helpers/reports.js

@@ -1,5 +1,5 @@
 import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
-import { isETag, isPTag } from "applesauce-core/helpers/tags";
+import { isETag, isNameValueTag, isPTag } from "applesauce-core/helpers/tags";
 export const ParsedReportSymbol = Symbol("parsed-report");
 export var ReportReason;
 (function (ReportReason) {
@@ -14,25 +14,29 @@ export var ReportReason;
 /** Reads a report event as either a user or event report */
 export function getReported(report) {
     return getOrComputeCachedValue(report, ParsedReportSymbol, () => {
-        const p = report.tags.find(isPTag);
-        if (!p)
-            throw new Error("Report missing p tag");
+        const pTag = report.tags.find(isPTag);
+        if (!pTag)
+            return null;
         const comment = report.content ? report.content.trim() : undefined;
-        const e = report.tags.find(isETag);
+        const eTag = report.tags.find(isETag);
         // Event report
-        if (e) {
+        if (eTag) {
             const blobs = report.tags.filter((t) => t[0] === "x" && t[1]).map((t) => t[1]);
             return {
                 type: "event",
                 event: report,
                 comment,
-                id: e[1],
-                pubkey: p[1],
-                reason: e[2],
+                id: eTag[1],
+                pubkey: pTag[1],
+                reason: eTag[2],
                 blobs,
             };
         }
         // User report
-        return { type: "user", event: report, comment, pubkey: p[1], reason: p[2] };
+        return { type: "user", event: report, comment, pubkey: pTag[1], reason: pTag[2] };
     });
 }
+/** Gets the server tags from a report event (for blob reports) */
+export function getReportServers(report) {
+    return report.tags.filter((t) => isNameValueTag(t, "server") && t[1]).map((t) => t[1]);
+}

package/dist/models/blossom.d.ts

@@ -2,10 +2,10 @@ import { Model } from "applesauce-core/event-store";
 import { ProfilePointer } from "applesauce-core/helpers/pointers";
 import { type Observable } from "rxjs";
 /** A model that returns a users blossom servers */
-export declare function UserBlossomServersModel(user: string | ProfilePointer): Model<URL[]>;
+export declare function UserBlossomServersModel(user: string | ProfilePointer): Model<URL[] | undefined>;
 declare module "applesauce-core/event-store" {
     interface EventModels {
         /** Subscribe to a users blossom servers */
-        blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+        blossomServers(user: string | ProfilePointer): Observable<URL[] | undefined>;
     }
 }

package/dist/models/blossom.js

@@ -8,7 +8,7 @@ export function UserBlossomServersModel(user) {
         user = { pubkey: user };
     return (store) => store
         .replaceable({ kind: BLOSSOM_SERVER_LIST_KIND, pubkey: user.pubkey, relays: user.relays })
-        .pipe(map((event) => (event ? getBlossomServersFromList(event) : [])));
+        .pipe(map((event) => event && getBlossomServersFromList(event)));
 }
 // Register this model with EventModels
 EventModels.prototype.blossomServers = function (user) {

package/dist/models/channels.js

@@ -31,15 +31,9 @@ export function ChannelMetadataModel(channel) {
         ];
         let latest = channel;
         return events.filters(filters).pipe(map((event) => {
-            try {
-                if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
-                    latest = event;
-                }
-                return getChannelMetadataContent(latest);
-            }
-            catch (error) {
-                return undefined;
-            }
+            if (event.pubkey === latest.pubkey && event.created_at > latest.created_at)
+                latest = event;
+            return getChannelMetadataContent(latest) ?? undefined;
         }));
     };
 }

package/dist/models/comments.d.ts

@@ -1,11 +1,12 @@
 import { Model } from "applesauce-core/event-store";
 import { NostrEvent } from "applesauce-core/helpers/event";
 import { type Observable } from "rxjs";
+import { CommentPointer } from "../helpers/comment.js";
 /** A model that returns all NIP-22 comment replies for the event */
-export declare function CommentsModel(parent: NostrEvent): Model<NostrEvent[]>;
+export declare function CommentsModel(parent: NostrEvent | CommentPointer): Model<NostrEvent[]>;
 declare module "applesauce-core/event-store" {
     interface EventModels {
         /** Subscribe to an event's comments */
-        comments(event: NostrEvent): Observable<NostrEvent[]>;
+        comments(event: NostrEvent | CommentPointer): Observable<NostrEvent[]>;
     }
 }

package/dist/models/comments.js

@@ -1,9 +1,27 @@
 import { EventModels } from "applesauce-core/event-store";
+import { createReplaceableAddress, isEvent } from "applesauce-core/helpers/event";
 import { buildCommonEventRelationFilters } from "applesauce-core/helpers/model";
+import { of } from "rxjs";
 import { COMMENT_KIND } from "../helpers/comment.js";
 /** A model that returns all NIP-22 comment replies for the event */
 export function CommentsModel(parent) {
-    return (events) => events.timeline(buildCommonEventRelationFilters({ kinds: [COMMENT_KIND] }, parent));
+    return (events) => {
+        if (isEvent(parent))
+            return events.timeline(buildCommonEventRelationFilters({ kinds: [COMMENT_KIND] }, parent));
+        else {
+            switch (parent.type) {
+                case "event":
+                    return events.timeline({ kinds: [COMMENT_KIND], "#e": [parent.id] });
+                case "address":
+                    return events.timeline({
+                        kinds: [COMMENT_KIND],
+                        "#a": [createReplaceableAddress(parent.kind, parent.pubkey, parent.identifier)],
+                    });
+                default:
+                    return of([]);
+            }
+        }
+    };
 }
 // Register this model with EventModels
 EventModels.prototype.comments = function (event) {

package/dist/operations/comment.d.ts

@@ -1,4 +1,5 @@
 import { EventOperation } from "applesauce-core/event-factory";
 import { NostrEvent } from "applesauce-core/helpers/event";
-/** Sets the necessary tags for a NIP-22 comment event to point to a parent event */
-export declare function setParent(parent: NostrEvent): EventOperation;
+import { CommentPointer } from "../helpers/comment.js";
+/** Sets the necessary tags for a NIP-22 comment event to point to a parent event or pointer */
+export declare function setParent(parent: NostrEvent | CommentPointer): EventOperation;

package/dist/operations/comment.js

@@ -1,11 +1,25 @@
-import { createCommentTagsForEvent } from "../helpers/comment.js";
-/** Sets the necessary tags for a NIP-22 comment event to point to a parent event */
+import { isEvent } from "applesauce-core/helpers/event";
+import { COMMENT_KIND, createCommentTagsForEvent, createCommentTagsFromCommentPointer, } from "../helpers/comment.js";
+/** Sets the necessary tags for a NIP-22 comment event to point to a parent event or pointer */
 export function setParent(parent) {
     return async (draft, ctx) => {
-        const relayHint = await ctx.getEventRelayHint?.(parent.id);
         let tags = Array.from(draft.tags);
-        // add NIP-22 comment tags
-        tags.push(...createCommentTagsForEvent(parent, relayHint));
+        // If parent is a CommentPointer (not a NostrEvent), handle it directly
+        if (!isEvent(parent)) {
+            if (parent.kind === COMMENT_KIND)
+                throw new Error("Comment pointer cannot be a comment kind. please pass the full nip-22 comment event");
+            // For CommentPointer, treat as root comment: both root and reply tags point to the same pointer
+            // Note: relay hints are already included in the pointer if available
+            // Add root tags (capitalized)
+            tags.push(...createCommentTagsFromCommentPointer(parent, true));
+            // Add reply tags (lowercase)
+            tags.push(...createCommentTagsFromCommentPointer(parent, false));
+        }
+        else {
+            // If parent is a NostrEvent, use existing logic
+            const relayHint = await ctx.getEventRelayHint?.(parent.id);
+            tags.push(...createCommentTagsForEvent(parent, relayHint));
+        }
         return { ...draft, tags };
     };
 }

package/dist/operations/torrent.d.ts

@@ -22,6 +22,8 @@ export declare function addTorrentSearchTag(tag: string): EventOperation;
 export declare function removeTorrentSearchTag(tag: string): EventOperation;
 /** Sets the category path (tcat) */
 export declare function setTorrentCategoryPath(categoryPath: string): EventOperation;
+/** Removes the category path (tcat) */
+export declare function removeTorrentCategoryPath(): EventOperation;
 /** Adds an external identifier */
 export declare function addTorrentExternalIdentifier(identifier: TorrentExternalIdentifier): EventOperation;
 /**

package/dist/operations/torrent.js

@@ -48,6 +48,10 @@ export function removeTorrentSearchTag(tag) {
 export function setTorrentCategoryPath(categoryPath) {
     return modifyPublicTags(setSingletonTag(["i", `tcat:${categoryPath}`]));
 }
+/** Removes the category path (tcat) */
+export function removeTorrentCategoryPath() {
+    return modifyPublicTags((tags) => tags.filter((t) => !(t[0] === "i" && t[1]?.startsWith("tcat:"))));
+}
 /** Adds an external identifier */
 export function addTorrentExternalIdentifier(identifier) {
     return modifyPublicTags(addNameValueTag(["i", identifier.identifier], false));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-common",
-  "version": "0.0.0-next-20251220152312",
+  "version": "0.0.0-next-20251231055351",
   "description": "Common NIP-specific helpers and models for applesauce",
   "type": "module",
   "main": "dist/index.js",
@@ -83,7 +83,7 @@
   },
   "dependencies": {
     "@scure/base": "^1.2.4",
-    "applesauce-core": "0.0.0-next-20251220152312",
+    "applesauce-core": "0.0.0-next-20251231055351",
     "hash-sum": "^2.0.0",
     "light-bolt11-decoder": "^3.2.0",
     "rxjs": "^7.8.1"