applesauce-common 0.0.0-next-20251203172109

package/dist/helpers/bookmark.js

@@ -0,0 +1,96 @@
+import { getOrComputeCachedValue, notifyEventUpdate } from "applesauce-core/helpers";
+import { kinds } from "applesauce-core/helpers/event";
+import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
+import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, mergeAddressPointers, mergeEventPointers, } from "applesauce-core/helpers/pointers";
+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);
+    const articles = tags
+        .filter((t) => t[0] === "a" && t[1])
+        .map(getAddressPointerFromATag)
+        .filter((addr) => addr.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 };
+}
+/** 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);
+            if (existing)
+                notes.set(note.id, mergeEventPointers(existing, note));
+            else
+                notes.set(note.id, note);
+        }
+        for (const article of bookmark.articles) {
+            const coord = getCoordinateFromAddressPointer(article);
+            const existing = articles.get(coord);
+            if (existing)
+                articles.set(coord, mergeAddressPointers(existing, article));
+            else
+                articles.set(coord, article);
+        }
+        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),
+    };
+}
+/** Returns all 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);
+}
+export function getHiddenBookmarks(bookmark) {
+    if (isHiddenBookmarksUnlocked(bookmark))
+        return bookmark[BookmarkHiddenSymbol];
+    //get hidden tags
+    const tags = getHiddenTags(bookmark);
+    if (!tags)
+        return undefined;
+    // parse bookmarks
+    const bookmarks = parseBookmarkTags(tags);
+    // set cached value
+    Reflect.set(bookmark, BookmarkHiddenSymbol, bookmarks);
+    return bookmarks;
+}
+/** Unlocks the hidden bookmarks on a bookmarks event */
+export async function unlockHiddenBookmarks(bookmark, signer) {
+    if (isHiddenBookmarksUnlocked(bookmark))
+        return bookmark[BookmarkHiddenSymbol];
+    // unlock hidden tags
+    await unlockHiddenTags(bookmark, signer);
+    // get hidden bookmarks
+    const bookmarks = getHiddenBookmarks(bookmark);
+    if (!bookmarks)
+        throw new Error("Failed to unlock hidden bookmarks");
+    // notify event store
+    notifyEventUpdate(bookmark);
+    return bookmarks;
+}

package/dist/helpers/calendar-event.d.ts

@@ -0,0 +1,39 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { ProfilePointer } from "applesauce-core/helpers/pointers";
+import { NameValueTag } from "applesauce-core/helpers/tags";
+export declare const DATE_BASED_CALENDAR_EVENT_KIND = 31922;
+export declare const TIME_BASED_CALENDAR_EVENT_KIND = 31923;
+export type CalendarEventParticipant = ProfilePointer & {
+    role?: string;
+};
+export declare const CalendarEventLocationsSymbol: unique symbol;
+export declare const CalendarEventParticipantsSymbol: unique symbol;
+export declare const CalendarEventHashtagsSymbol: unique symbol;
+export declare const CalendarEventReferencesSymbol: unique symbol;
+export declare const CalendarEventGeohashSymbol: unique symbol;
+/** Gets the title of a calendar event or calendar */
+export declare function getCalendarEventTitle(event: NostrEvent): string | undefined;
+/** Gets the summary of a calendar event */
+export declare function getCalendarEventSummary(event: NostrEvent): string | undefined;
+/** Gets the image URL of a calendar event */
+export declare function getCalendarEventImage(event: NostrEvent): string | undefined;
+/** Gets the start Unix timestamp of a calendar event */
+export declare function getCalendarEventStart(event: NostrEvent): number | undefined;
+/** Gets the timezone of the start timestamp of a calendar event */
+export declare function getCalendarEventStartTimezone(event: NostrEvent): string | undefined;
+/** Gets the timezone of the end timestamp of a calendar event */
+export declare function getCalendarEventEndTimezone(event: NostrEvent): string | undefined;
+/** Gets the end Unix timestamp of a calendar event */
+export declare function getCalendarEventEnd(event: NostrEvent): number | undefined;
+/** Gets all locations from a calendar event */
+export declare function getCalendarEventLocations(event: NostrEvent): string[];
+/** Gets the geohash of a calendar event */
+export declare function getCalendarEventGeohash(event: NostrEvent): string | undefined;
+/** Gets all participants from a calendar event */
+export declare function getCalendarEventParticipants(event: NostrEvent): CalendarEventParticipant[];
+/** Gets all hashtags from a calendar event */
+export declare function getCalendarEventHashtags(event: NostrEvent): string[];
+/** Gets all references from a calendar event */
+export declare function getCalendarEventReferences(event: NostrEvent): string[];
+/** Creates a "p" tag for a calendar event participant */
+export declare function createCalendarEventParticipantTag(participant: CalendarEventParticipant): NameValueTag;

package/dist/helpers/calendar-event.js

@@ -0,0 +1,121 @@
+import { createPTagFromProfilePointer } from "applesauce-core/helpers";
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getProfilePointerFromPTag } from "applesauce-core/helpers/pointers";
+import { fillAndTrimTag, isPTag, isRTag, isTTag } from "applesauce-core/helpers/tags";
+// NIP-52 Calendar Event Kinds
+export const DATE_BASED_CALENDAR_EVENT_KIND = 31922;
+export const TIME_BASED_CALENDAR_EVENT_KIND = 31923;
+// Cache symbols for complex operations only
+export const CalendarEventLocationsSymbol = Symbol.for("calendar-event-locations");
+export const CalendarEventParticipantsSymbol = Symbol.for("calendar-event-participants");
+export const CalendarEventHashtagsSymbol = Symbol.for("calendar-event-hashtags");
+export const CalendarEventReferencesSymbol = Symbol.for("calendar-event-references");
+export const CalendarEventGeohashSymbol = Symbol.for("calendar-event-geohash");
+/** Gets the title of a calendar event or calendar */
+export function getCalendarEventTitle(event) {
+    return getTagValue(event, "title") || getTagValue(event, "name"); // fallback to deprecated "name" tag
+}
+/** Gets the summary of a calendar event */
+export function getCalendarEventSummary(event) {
+    return getTagValue(event, "summary");
+}
+/** Gets the image URL of a calendar event */
+export function getCalendarEventImage(event) {
+    return getTagValue(event, "image");
+}
+/** Gets the start Unix timestamp of a calendar event */
+export function getCalendarEventStart(event) {
+    const value = getTagValue(event, "start");
+    if (!value)
+        return undefined;
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return new Date(value).valueOf() / 1000;
+    else if (event.kind === TIME_BASED_CALENDAR_EVENT_KIND)
+        return parseInt(value);
+    else
+        return undefined;
+}
+/** Gets the timezone of the start timestamp of a calendar event */
+export function getCalendarEventStartTimezone(event) {
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return undefined;
+    return getTagValue(event, "start_tzid");
+}
+/** Gets the timezone of the end timestamp of a calendar event */
+export function getCalendarEventEndTimezone(event) {
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return undefined;
+    return getTagValue(event, "end_tzid");
+}
+/** Gets the end Unix timestamp of a calendar event */
+export function getCalendarEventEnd(event) {
+    const value = getTagValue(event, "end");
+    if (!value)
+        return undefined;
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return new Date(value).valueOf() / 1000;
+    else if (event.kind === TIME_BASED_CALENDAR_EVENT_KIND)
+        return parseInt(value);
+    else
+        return undefined;
+}
+/** Gets all locations from a calendar event */
+export function getCalendarEventLocations(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventLocationsSymbol, () => {
+        return event.tags.filter((t) => t[0] === "location" && t[1]).map((t) => t[1]);
+    });
+}
+/** Gets the geohash of a calendar event */
+export function getCalendarEventGeohash(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventGeohashSymbol, () => {
+        let hash = undefined;
+        for (const tag of event.tags) {
+            if (tag[0] === "g" && tag[1] && (!hash || tag[1].length > hash.length))
+                hash = tag[1];
+        }
+        return hash;
+    });
+}
+/** Gets all participants from a calendar event */
+export function getCalendarEventParticipants(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventParticipantsSymbol, () => {
+        return event.tags.filter(isPTag).map((tag) => ({
+            ...getProfilePointerFromPTag(tag),
+            // Third index of tag is optional "role"
+            role: tag[3] || undefined,
+        }));
+    });
+}
+/** Gets all hashtags from a calendar event */
+export function getCalendarEventHashtags(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventHashtagsSymbol, () => {
+        return event.tags.filter(isTTag).map((t) => t[1]);
+    });
+}
+/** Gets all references from a calendar event */
+export function getCalendarEventReferences(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventReferencesSymbol, () => {
+        return event.tags.filter(isRTag).map((t) => t[1]);
+    });
+}
+/** Creates a "p" tag for a calendar event participant */
+export function createCalendarEventParticipantTag(participant) {
+    const tag = createPTagFromProfilePointer(participant);
+    // Add the third "role" value if set
+    if (participant.role) {
+        tag[3] = participant.role;
+        return fillAndTrimTag(tag, 3);
+    }
+    return tag;
+}

package/dist/helpers/calendar-rsvp.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer, ProfilePointer } from "applesauce-core/helpers/pointers";
+export declare const CALENDAR_EVENT_RSVP_KIND = 31925;
+export type RSVPStatus = "accepted" | "declined" | "tentative";
+export type RSVPFreeBusy = "free" | "busy";
+/** Gets the RSVP status from a calendar event RSVP */
+export declare function getRSVPStatus(event: NostrEvent): RSVPStatus | undefined;
+/** Gets the free/busy status from a calendar event RSVP (will be undefined if the RSVP is declined) */
+export declare function getRSVPFreeBusy(event: NostrEvent): RSVPFreeBusy | undefined;
+/** Gets the referenced calendar event coordinate that the RSVP is responding to */
+export declare function getRSVPAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Gets the referenced calendar event pointer that the RSVP is responding to */
+export declare function getRSVPEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Gets the profile pointer that the RSVP is responding to */
+export declare function getRSVPProfilePointer(event: NostrEvent): ProfilePointer | undefined;

package/dist/helpers/calendar-rsvp.js

@@ -0,0 +1,38 @@
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag, } from "applesauce-core/helpers/pointers";
+import { isATag, isETag, isPTag } from "applesauce-core/helpers/tags";
+export const CALENDAR_EVENT_RSVP_KIND = 31925;
+/** Gets the RSVP status from a calendar event RSVP */
+export function getRSVPStatus(event) {
+    const status = getTagValue(event, "status");
+    return status && ["accepted", "declined", "tentative"].includes(status) ? status : undefined;
+}
+/** Gets the free/busy status from a calendar event RSVP (will be undefined if the RSVP is declined) */
+export function getRSVPFreeBusy(event) {
+    const status = getRSVPStatus(event);
+    if (status === "declined")
+        return undefined;
+    const fb = getTagValue(event, "fb");
+    return fb && ["free", "busy"].includes(fb) ? fb : undefined;
+}
+/** Gets the referenced calendar event coordinate that the RSVP is responding to */
+export function getRSVPAddressPointer(event) {
+    const tag = event.tags.find(isATag);
+    if (!tag)
+        return undefined;
+    return getAddressPointerFromATag(tag);
+}
+/** Gets the referenced calendar event pointer that the RSVP is responding to */
+export function getRSVPEventPointer(event) {
+    const tag = event.tags.find(isETag);
+    if (!tag)
+        return undefined;
+    return getEventPointerFromETag(tag);
+}
+/** Gets the profile pointer that the RSVP is responding to */
+export function getRSVPProfilePointer(event) {
+    const tag = event.tags.find(isPTag);
+    if (!tag)
+        return undefined;
+    return getProfilePointerFromPTag(tag);
+}

package/dist/helpers/calendar.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+/** Gets the title of a calendar */
+export declare function getCalendarTitle(event: NostrEvent): string | undefined;
+/** Gets the address pointers to all the events on the calendar */
+export declare function getCalendarAddressPointers(event: NostrEvent): AddressPointer[];

package/dist/helpers/calendar.js

@@ -0,0 +1,11 @@
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getAddressPointerFromATag } from "applesauce-core/helpers/pointers";
+import { isATag } from "applesauce-core/helpers/tags";
+/** Gets the title of a calendar */
+export function getCalendarTitle(event) {
+    return getTagValue(event, "title");
+}
+/** Gets the address pointers to all the events on the calendar */
+export function getCalendarAddressPointers(event) {
+    return event.tags.filter(isATag).map(getAddressPointerFromATag);
+}

package/dist/helpers/channels.d.ts

@@ -0,0 +1,13 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { EventPointer } from "applesauce-core/helpers/pointers";
+export declare const ChannelMetadataSymbol: unique symbol;
+export type ChannelMetadataContent = {
+    name: string;
+    about: string;
+    picture: string;
+    relays?: string[];
+};
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+/** gets the EventPointer for a channel message or metadata event */
+export declare function getChannelPointer(event: NostrEvent): EventPointer | undefined;

package/dist/helpers/channels.js

@@ -0,0 +1,27 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+export const ChannelMetadataSymbol = Symbol.for("channel-metadata");
+function parseChannelMetadataContent(channel) {
+    const metadata = JSON.parse(channel.content);
+    if (metadata.name === undefined)
+        throw new Error("Missing name");
+    if (metadata.about === undefined)
+        throw new Error("Missing about");
+    if (metadata.picture === undefined)
+        throw new Error("Missing picture");
+    if (metadata.relays && !Array.isArray(metadata.relays))
+        throw new Error("Invalid relays");
+    return metadata;
+}
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export function getChannelMetadataContent(channel) {
+    return getOrComputeCachedValue(channel, ChannelMetadataSymbol, () => {
+        return parseChannelMetadataContent(channel);
+    });
+}
+/** gets the EventPointer for a channel message or metadata event */
+export function getChannelPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e" && t[1]);
+    if (!tag)
+        return undefined;
+    return tag[2] ? { id: tag[1], relays: [tag[2]] } : { id: tag[1] };
+}

package/dist/helpers/comment.d.ts

@@ -0,0 +1,47 @@
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { ExternalIdentifiers, ExternalPointer } from "applesauce-core/helpers/external-id";
+export declare const COMMENT_KIND = 1111;
+/** Type for validated comment events */
+export type CommentEvent = KnownEvent<typeof COMMENT_KIND>;
+export type CommentEventPointer = {
+    type: "event";
+    id: string;
+    kind: number;
+    pubkey?: string;
+    relay?: string;
+};
+export type CommentAddressPointer = {
+    type: "address";
+    id?: string;
+    kind: number;
+    pubkey: string;
+    identifier: string;
+    relay?: string;
+};
+export type CommentExternalPointer<T extends keyof ExternalIdentifiers> = ExternalPointer<T> & {
+    type: "external";
+};
+export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer<keyof ExternalIdentifiers>;
+export declare const CommentRootPointerSymbol: unique symbol;
+export declare const CommentReplyPointerSymbol: unique symbol;
+/** Gets the EventPointer from an array of tags */
+export declare function getCommentEventPointer(tags: string[][], root?: boolean): CommentEventPointer | null;
+/** Gets the AddressPointer from an array of tags */
+export declare function getCommentAddressPointer(tags: string[][], root?: boolean): CommentAddressPointer | null;
+/** Gets the ExternalPointer from an array of tags */
+export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer<keyof ExternalIdentifiers> | null;
+/** Returns the root pointer for a comment */
+export declare function getCommentRootPointer(comment: CommentEvent): CommentPointer;
+export declare function getCommentRootPointer(comment: NostrEvent): CommentPointer | null;
+/** Returns the reply pointer for a comment */
+export declare function getCommentReplyPointer(comment: NostrEvent): CommentPointer | null;
+/** Checks if a pointer is a {@link CommentEventPointer} */
+export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
+/** Checks if a pointer is a {@link CommentAddressPointer} */
+export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;
+/** Checks if a comment event is valid */
+export declare function isValidComment(comment: NostrEvent): comment is CommentEvent;
+/** Create a set fo tags for a single CommentPointer */
+export declare function createCommentTagsFromCommentPointer(pointer: CommentPointer, root?: boolean): string[][];
+/** Returns an array of NIP-22 tags for a kind 1111 comment event */
+export declare function createCommentTagsForEvent(parent: NostrEvent, relayHint?: string): string[][];

package/dist/helpers/comment.js

@@ -0,0 +1,185 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { createReplaceableAddress, getTagValue, isAddressableKind, } from "applesauce-core/helpers/event";
+import { getExternalPointerFromTag } from "applesauce-core/helpers/external-id";
+import { getAddressPointerFromATag } from "applesauce-core/helpers/pointers";
+import { isSafeRelayURL } from "applesauce-core/helpers/relays";
+import { fillAndTrimTag } from "applesauce-core/helpers/tags";
+export const COMMENT_KIND = 1111;
+export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
+export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
+/** Gets the EventPointer from an array of tags */
+export function getCommentEventPointer(tags, root = false) {
+    const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (eTag) {
+        // Missing kind tag, return null
+        if (!kind)
+            return null;
+        // only the root pubkey can be gotten from the tags, since due to quotes and mentions there will be many "p" tags for replies
+        const rootPubkey = root ? tags.find((t) => t[0] === "P")?.[1] : undefined;
+        const pointer = {
+            type: "event",
+            id: eTag[1],
+            kind: parseInt(kind),
+            pubkey: eTag[3] || rootPubkey || undefined,
+            relay: eTag[2] && isSafeRelayURL(eTag[2]) ? eTag[2] : undefined,
+        };
+        return pointer;
+    }
+    return null;
+}
+/** Gets the AddressPointer from an array of tags */
+export function getCommentAddressPointer(tags, root = false) {
+    const aTag = tags.find((t) => t[0] === (root ? "A" : "a"));
+    const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (aTag) {
+        // Missing kind tag, return null
+        if (!kind)
+            return null;
+        const addressPointer = getAddressPointerFromATag(aTag);
+        const pointer = {
+            type: "address",
+            id: eTag?.[1],
+            pubkey: addressPointer.pubkey,
+            identifier: addressPointer.identifier,
+            kind: addressPointer.kind || parseInt(kind),
+            relay: addressPointer.relays?.[0] || eTag?.[2],
+        };
+        return pointer;
+    }
+    return null;
+}
+/** Gets the ExternalPointer from an array of tags */
+export function getCommentExternalPointer(tags, root = false) {
+    const iTag = tags.find((t) => t[0] === (root ? "I" : "i"));
+    if (iTag) {
+        return {
+            type: "external",
+            ...getExternalPointerFromTag(iTag),
+        };
+    }
+    return null;
+}
+export function getCommentRootPointer(comment) {
+    if (comment.kind !== COMMENT_KIND)
+        return null;
+    return getOrComputeCachedValue(comment, CommentRootPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, true);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, true);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, true);
+        if (I)
+            return I;
+        return null;
+    });
+}
+/** Returns the reply pointer for a comment */
+export function getCommentReplyPointer(comment) {
+    if (comment.kind !== COMMENT_KIND)
+        return null;
+    return getOrComputeCachedValue(comment, CommentReplyPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, false);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, false);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, false);
+        if (I)
+            return I;
+        return null;
+    });
+}
+/** Checks if a pointer is a {@link CommentEventPointer} */
+export function isCommentEventPointer(pointer) {
+    return (Reflect.has(pointer, "id") &&
+        Reflect.has(pointer, "kind") &&
+        !Reflect.has(pointer, "identifier") &&
+        typeof pointer.kind === "number");
+}
+/** Checks if a pointer is a {@link CommentAddressPointer} */
+export function isCommentAddressPointer(pointer) {
+    return (Reflect.has(pointer, "identifier") &&
+        Reflect.has(pointer, "pubkey") &&
+        Reflect.has(pointer, "kind") &&
+        typeof pointer.kind === "number");
+}
+/** Checks if a comment event is valid */
+export function isValidComment(comment) {
+    return (comment.kind === COMMENT_KIND && getCommentRootPointer(comment) !== null && getCommentReplyPointer(comment) !== null);
+}
+/** Create a set fo tags for a single CommentPointer */
+export function createCommentTagsFromCommentPointer(pointer, root = false) {
+    if (isCommentEventPointer(pointer)) {
+        // Event pointer
+        return [
+            fillAndTrimTag([root ? "E" : "e", pointer.id, pointer.relay, pointer.pubkey]),
+            [root ? "K" : "k", String(pointer.kind)],
+            pointer.pubkey ? fillAndTrimTag([root ? "P" : "p", pointer.pubkey]) : undefined,
+        ].filter((t) => !!t);
+    }
+    else if (isCommentAddressPointer(pointer)) {
+        // Address pointer
+        return [
+            fillAndTrimTag([
+                root ? "A" : "a",
+                createReplaceableAddress(pointer.kind, pointer.pubkey, pointer.identifier),
+                pointer.relay,
+            ]),
+            pointer.id ? fillAndTrimTag([root ? "E" : "e", pointer.id, pointer.relay, pointer.pubkey]) : undefined,
+            [root ? "K" : "k", String(pointer.kind)],
+            pointer.pubkey ? fillAndTrimTag([root ? "P" : "p", pointer.pubkey]) : undefined,
+        ].filter((t) => !!t);
+    }
+    else {
+        // External pointer
+        return [
+            [root ? "I" : "i", pointer.identifier],
+            [root ? "K" : "k", pointer.kind],
+        ];
+    }
+    throw new Error("Unknown comment pointer kind");
+}
+/** Returns an array of NIP-22 tags for a kind 1111 comment event */
+export function createCommentTagsForEvent(parent, relayHint) {
+    const tags = [];
+    let parentPointer;
+    if (isAddressableKind(parent.kind)) {
+        const identifier = getTagValue(parent, "d");
+        if (!identifier)
+            throw new Error("Event missing identifier");
+        parentPointer = {
+            type: "address",
+            id: parent.id,
+            pubkey: parent.pubkey,
+            kind: parent.kind,
+            relay: relayHint,
+            identifier,
+        };
+    }
+    else {
+        parentPointer = { type: "event", id: parent.id, pubkey: parent.pubkey, kind: parent.kind, relay: relayHint };
+    }
+    // check if parent event is a comment
+    if (parent.kind === COMMENT_KIND) {
+        // comment is a reply to another comment
+        const pointer = getCommentRootPointer(parent);
+        if (!pointer)
+            throw new Error("Comment missing root pointer");
+        // recreate the root tags
+        tags.push(...createCommentTagsFromCommentPointer(pointer, true));
+    }
+    else {
+        // comment is root comment
+        tags.push(...createCommentTagsFromCommentPointer(parentPointer, true));
+    }
+    // add reply tags
+    tags.push(...createCommentTagsFromCommentPointer(parentPointer, false));
+    return tags;
+}

package/dist/helpers/content.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export declare function getContentWarning(event: NostrEvent): string | boolean;

package/dist/helpers/content.js

@@ -0,0 +1,8 @@
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export function getContentWarning(event) {
+    const tag = event.tags.find((t) => t[0] === "content-warning");
+    if (tag)
+        return tag[1] || true;
+    else
+        return false;
+}

package/dist/helpers/emoji.d.ts

@@ -0,0 +1,21 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+export type Emoji = {
+    /** The emoji shortcode (without the ::) */
+    shortcode: string;
+    /** The URL to the emoji image */
+    url: string;
+};
+/** Gets an "emoji" tag that matches an emoji code */
+export declare function getEmojiTag(tags: {
+    tags: string[][];
+} | string[][], code: string): ["emoji", string, string] | undefined;
+/** Gets an emoji for a shortcode from an array of tags or event */
+export declare function getEmojiFromTags(event: {
+    tags: string[][];
+} | string[][], code: string): Emoji | undefined;
+/** Returns the name of a NIP-30 emoji pack */
+export declare function getPackName(pack: NostrEvent): string | undefined;
+/** Returns an array of emojis from a NIP-30 emoji pack */
+export declare function getEmojis(pack: NostrEvent): Emoji[];
+/** Returns the custom emoji for a reaction event */
+export declare function getReactionEmoji(event: NostrEvent): Emoji | undefined;