applesauce-common 0.0.0-next-20251203172109

package/dist/helpers/groups.d.ts

@@ -0,0 +1,26 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+export declare const GROUPS_LIST_KIND = 10009;
+export declare const GROUP_MESSAGE_KIND = 9;
+/** NIP-29 group pointer */
+export type GroupPointer = {
+    /** the id of the group */
+    id: string;
+    /** The url to the relay with wss:// or ws:// protocol */
+    relay: string;
+    /** The name of the group */
+    name?: string;
+};
+/** decodes a group identifier into a group pointer object */
+export declare function decodeGroupPointer(str: string): GroupPointer | null;
+/** Converts a group pointer into a group identifier */
+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;
+/** 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;

package/dist/helpers/groups.js

@@ -0,0 +1,49 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getHiddenTags } 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;
+export const GROUP_MESSAGE_KIND = 9;
+/** decodes a group identifier into a group pointer object */
+export function decodeGroupPointer(str) {
+    let [relay, id] = str.split("'");
+    if (!relay)
+        return null;
+    // Prepend wss:// if missing
+    if (!relay.match(/^wss?:/))
+        relay = `wss://${relay}`;
+    // Normalize the relay url
+    relay = normalizeURL(relay);
+    return { relay, id: id || "_" };
+}
+/** Converts a group pointer into a group identifier */
+export function encodeGroupPointer(pointer) {
+    const hostname = URL.canParse(pointer.relay) ? new URL(pointer.relay).hostname : pointer.relay;
+    return `${hostname}'${pointer.id}`;
+}
+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;
+    if (!id || !relay)
+        return undefined;
+    return { id, relay };
+}
+/** gets a {@link GroupPointer} from a "group" tag */
+export function getGroupPointerFromGroupTag(tag) {
+    const [_, id, relay, name] = tag;
+    return { id, relay, name };
+}
+/** Returns all the public groups from a k:10009 list */
+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) {
+    return getOrComputeCachedValue(bookmark, GroupsHiddenSymbol, () => {
+        const tags = getHiddenTags(bookmark);
+        return (tags &&
+            processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+    });
+}

package/dist/helpers/hashtag.d.ts

@@ -0,0 +1,2 @@
+import { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
+export declare function getHashtagTag(event: NostrEvent | EventTemplate, hashtag: string): ["t", string];

package/dist/helpers/hashtag.js

@@ -0,0 +1,7 @@
+import { stripInvisibleChar } from "applesauce-core/helpers/string";
+export function getHashtagTag(event, hashtag) {
+    hashtag = stripInvisibleChar(hashtag.replace(/^#/, "").toLocaleLowerCase());
+    return event.tags
+        .filter((t) => t[0] === "t" && t[1])
+        .find((t) => stripInvisibleChar(t[1].toLowerCase()) === hashtag);
+}

package/dist/helpers/highlight.d.ts

@@ -0,0 +1,45 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer, ProfilePointer } from "applesauce-core/helpers/pointers";
+export declare const HighlightSourceEventPointerSymbol: unique symbol;
+export declare const HighlightSourceAddressPointerSymbol: unique symbol;
+export declare const HighlightAttributionSymbol: unique symbol;
+/**
+ * Get the highlighted content from a highlight event
+ * Returns the content field which contains the highlighted text
+ */
+export declare function getHighlightText(event: NostrEvent): string;
+/**
+ * Get the source event pointer that was highlighted (from 'e' tag)
+ * Returns undefined if no event reference is found
+ */
+export declare function getHighlightSourceEventPointer(event: NostrEvent): EventPointer | undefined;
+/**
+ * Get the source address pointer that was highlighted (from 'a' tag)
+ * Returns undefined if no address reference is found
+ */
+export declare function getHighlightSourceAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Get the source URL that was highlighted (from 'r' tag) */
+export declare function getHighlightSourceUrl(event: NostrEvent): string | undefined;
+/** Role of an attributed profiles in a highlight */
+export type HighlightAttributionRole = "author" | "editor" | "mention" | string;
+/** Attribution information for a highlight */
+export type HighlightAttribution = ProfilePointer & {
+    /** Role of the attributed profile */
+    role?: HighlightAttributionRole;
+};
+/**
+ * Get attribution information from p tags
+ * Parses p tags to extract authors, editors, and other attributed individuals
+ */
+export declare function getHighlightAttributions(event: NostrEvent): HighlightAttribution[];
+/**
+ * Get the context text for a highlight (from 'context' tag)
+ * This provides surrounding content to give context to the highlight
+ */
+export declare function getHighlightContext(event: NostrEvent): string | undefined;
+/** Get the comment for a highlight (from 'comment' tag) */
+export declare function getHighlightComment(event: NostrEvent): string | undefined;
+/**
+ * Check if the highlight has any source reference (event, address, or URL)
+ */
+export declare function hasHighlightSource(event: NostrEvent): boolean;

package/dist/helpers/highlight.js

@@ -0,0 +1,76 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+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";
+// Symbol constants for caching
+export const HighlightSourceEventPointerSymbol = Symbol.for("highlight-source-event-pointer");
+export const HighlightSourceAddressPointerSymbol = Symbol.for("highlight-source-address-pointer");
+export const HighlightAttributionSymbol = Symbol.for("highlight-attribution");
+/**
+ * Get the highlighted content from a highlight event
+ * Returns the content field which contains the highlighted text
+ */
+export function getHighlightText(event) {
+    return event.content;
+}
+/**
+ * Get the source event pointer that was highlighted (from 'e' tag)
+ * Returns undefined if no event reference is found
+ */
+export function getHighlightSourceEventPointer(event) {
+    return getOrComputeCachedValue(event, HighlightSourceEventPointerSymbol, () => {
+        const eTag = event.tags.find(isETag);
+        return eTag ? getEventPointerFromETag(eTag) : undefined;
+    });
+}
+/**
+ * Get the source address pointer that was highlighted (from 'a' tag)
+ * Returns undefined if no address reference is found
+ */
+export function getHighlightSourceAddressPointer(event) {
+    return getOrComputeCachedValue(event, HighlightSourceAddressPointerSymbol, () => {
+        const aTag = event.tags.find(isATag);
+        return aTag ? getAddressPointerFromATag(aTag) : undefined;
+    });
+}
+/** Get the source URL that was highlighted (from 'r' tag) */
+export function getHighlightSourceUrl(event) {
+    return getTagValue(event, "r");
+}
+/**
+ * Get attribution information from p tags
+ * Parses p tags to extract authors, editors, and other attributed individuals
+ */
+export function getHighlightAttributions(event) {
+    return getOrComputeCachedValue(event, HighlightAttributionSymbol, () => {
+        const attributions = [];
+        const pTags = event.tags.filter(isPTag);
+        for (const pTag of pTags) {
+            const pointer = getProfilePointerFromPTag(pTag);
+            const role = pTag[3] || "other"; // Role is the 4th element (index 3)
+            const entry = { ...pointer, role };
+            // Categorize by role
+            attributions.push(entry);
+        }
+        return attributions;
+    });
+}
+/**
+ * Get the context text for a highlight (from 'context' tag)
+ * This provides surrounding content to give context to the highlight
+ */
+export function getHighlightContext(event) {
+    return getTagValue(event, "context");
+}
+/** Get the comment for a highlight (from 'comment' tag) */
+export function getHighlightComment(event) {
+    return getTagValue(event, "comment");
+}
+/**
+ * Check if the highlight has any source reference (event, address, or URL)
+ */
+export function hasHighlightSource(event) {
+    return !!(getHighlightSourceEventPointer(event) ||
+        getHighlightSourceAddressPointer(event) ||
+        getHighlightSourceUrl(event));
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,37 @@
+export * from "./app-handler.js";
+export * from "./article.js";
+export * from "./blossom.js";
+export * from "./bolt11.js";
+export * from "./bookmark.js";
+export * from "./calendar-event.js";
+export * from "./calendar-rsvp.js";
+export * from "./calendar.js";
+export * from "./channels.js";
+export * from "./comment.js";
+export * from "./content.js";
+export * from "./emoji.js";
+export * from "./encrypted-content-cache.js";
+export * from "./file-metadata.js";
+export * from "./gift-wrap.js";
+export * from "./groups.js";
+export * from "./hashtag.js";
+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";
+export * from "./poll.js";
+export * from "./reaction.js";
+export * from "./relay-discovery.js";
+export * from "./reports.js";
+export * from "./share.js";
+export * from "./stream-chat.js";
+export * from "./stream.js";
+export * from "./threading.js";
+export * from "./torrent.js";
+export * from "./user-status.js";
+export * from "./wrapped-messages.js";
+export * from "./zap.js";

package/dist/helpers/index.js

@@ -0,0 +1,37 @@
+export * from "./app-handler.js";
+export * from "./article.js";
+export * from "./blossom.js";
+export * from "./bolt11.js";
+export * from "./bookmark.js";
+export * from "./calendar-event.js";
+export * from "./calendar-rsvp.js";
+export * from "./calendar.js";
+export * from "./channels.js";
+export * from "./comment.js";
+export * from "./content.js";
+export * from "./emoji.js";
+export * from "./encrypted-content-cache.js";
+export * from "./file-metadata.js";
+export * from "./gift-wrap.js";
+export * from "./groups.js";
+export * from "./hashtag.js";
+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";
+export * from "./poll.js";
+export * from "./reaction.js";
+export * from "./relay-discovery.js";
+export * from "./reports.js";
+export * from "./share.js";
+export * from "./stream-chat.js";
+export * from "./stream.js";
+export * from "./threading.js";
+export * from "./torrent.js";
+export * from "./user-status.js";
+export * from "./wrapped-messages.js";
+export * from "./zap.js";

package/dist/helpers/legacy-messages.d.ts

@@ -0,0 +1,31 @@
+import { EncryptedContentSigner, UnlockedEncryptedContent } from "applesauce-core/helpers/encrypted-content";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+/** Type for valid legacy direct messages */
+export type LegacyMessage = KnownEvent<kinds.EncryptedDirectMessage>;
+/** Type for a legacy direct message with unlocked encrypted content */
+export type UnlockedLegacyMessage = LegacyMessage & UnlockedEncryptedContent;
+/** Checks if a legacy direct message content is encrypted */
+export declare function isLegacyMessageUnlocked<T extends NostrEvent>(event: T): event is T & UnlockedEncryptedContent;
+/** Returns the correspondent of a legacy direct message */
+export declare function getLegacyMessageCorrespondent<T extends LegacyMessage>(message: T, self: string): string;
+export declare function getLegacyMessageCorrespondent<T extends NostrEvent>(message: T, self: string): string | undefined;
+/** Returns the receiver of a legacy direct me */
+export declare const getLegacyMessageReceiver: typeof getLegacyMessageCorrespondent;
+/** @deprecated use {@link getLegacyMessageCorrespondent} instead */
+export declare const getLegacyMessageCorraspondant: typeof getLegacyMessageCorrespondent;
+/** Returns the sender of a legacy direct message */
+export declare function getLegacyMessageSender(message: NostrEvent): string;
+/** Returns the parent message id of a legacy message */
+export declare function getLegacyMessageParent(message: NostrEvent): string | undefined;
+/** Checks if a legacy message is valid */
+export declare function isValidLegacyMessage(event: any): event is LegacyMessage;
+/**
+ * Returns the decrypted content of a direct message
+ * @param message - The message to decrypt
+ * @param self - The public key of the user
+ * @param signer - The signer to use to decrypt the message
+ * @returns The decrypted content of the message
+ */
+export declare function unlockLegacyMessage(message: NostrEvent, self: string, signer: EncryptedContentSigner): Promise<string>;
+/** Clears the cached plaintext of a direct message */
+export declare function lockLegacyMessage(message: NostrEvent): Promise<void>;

package/dist/helpers/legacy-messages.js

@@ -0,0 +1,49 @@
+import { getEncryptedContent, isEncryptedContentUnlocked, lockEncryptedContent, unlockEncryptedContent, } from "applesauce-core/helpers/encrypted-content";
+import { getTagValue, kinds } from "applesauce-core/helpers/event";
+/** Checks if a legacy direct message content is encrypted */
+export function isLegacyMessageUnlocked(event) {
+    return isEncryptedContentUnlocked(event);
+}
+export function getLegacyMessageCorrespondent(message, self) {
+    return message.pubkey === self ? getTagValue(message, "p") : message.pubkey;
+}
+/** Returns the receiver of a legacy direct me */
+export const getLegacyMessageReceiver = getLegacyMessageCorrespondent;
+/** @deprecated use {@link getLegacyMessageCorrespondent} instead */
+export const getLegacyMessageCorraspondant = getLegacyMessageCorrespondent;
+/** Returns the sender of a legacy direct message */
+export function getLegacyMessageSender(message) {
+    return message.pubkey;
+}
+/** Returns the parent message id of a legacy message */
+export function getLegacyMessageParent(message) {
+    return getTagValue(message, "e");
+}
+/** Checks if a legacy message is valid */
+export function isValidLegacyMessage(event) {
+    return (event.kind === kinds.EncryptedDirectMessage &&
+        getLegacyMessageCorrespondent(event, event.pubkey) !== undefined &&
+        event.content.length > 0);
+}
+/**
+ * Returns the decrypted content of a direct message
+ * @param message - The message to decrypt
+ * @param self - The public key of the user
+ * @param signer - The signer to use to decrypt the message
+ * @returns The decrypted content of the message
+ */
+export async function unlockLegacyMessage(message, self, signer) {
+    const cached = getEncryptedContent(message);
+    if (cached)
+        return cached;
+    // Get the correspondent
+    const correspondent = getLegacyMessageCorrespondent(message, self);
+    if (!correspondent)
+        throw new Error("No correspondent found");
+    // Unlock the encrypted content
+    return await unlockEncryptedContent(message, correspondent, signer);
+}
+/** Clears the cached plaintext of a direct message */
+export async function lockLegacyMessage(message) {
+    lockEncryptedContent(message);
+}

package/dist/helpers/lists.d.ts

@@ -0,0 +1,58 @@
+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[][];
+/**
+ * Checks if an event pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in EventPointer
+ * @param list - The list or set to check
+ * @param pointer - The event pointer to check
+ * @param type - Which types of tags to check
+ */
+export declare function isEventPointerInList(list: NostrEvent, pointer: string | EventPointer, type?: ReadListTags): boolean;
+/**
+ * Checks if an address pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in AddressPointer
+ * @param list - The list or set to check
+ * @param pointer - The address pointer to check
+ * @param type - Which types of tags to check
+ */
+export declare function isAddressPointerInList(list: NostrEvent, pointer: string | AddressPointer, type?: ReadListTags): boolean;
+/**
+ * Checks if an profile pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in ProfilePointer
+ * @param list - The list or set to check
+ * @param pointer - The profile pointer to check
+ * @param type - Which types of tags to check
+ */
+export declare function isProfilePointerInList(list: NostrEvent, pointer: string | ProfilePointer, type?: ReadListTags): boolean;
+/** Returns if an event is in a list */
+export declare function isEventInList(list: NostrEvent, event: NostrEvent): boolean;
+/**
+ * Returns all the EventPointer in a list or set
+ * @param list - The list or set to get the event pointers from
+ * @param type - Which types of tags to read
+ */
+export declare function getEventPointersFromList(list: NostrEvent, type?: ReadListTags): EventPointer[];
+/**
+ * Returns all the AddressPointer in a list or set
+ * @param list - The list or set to get the address pointers from
+ * @param type - Which types of tags to read
+ */
+export declare function getAddressPointersFromList(list: NostrEvent, type?: ReadListTags): AddressPointer[];
+/**
+ * Returns all the ProfilePointer in a list or set
+ * @param list - The list or set to get the profile pointers from
+ * @param type - Which types of tags to read
+ */
+export declare function getProfilePointersFromList(list: NostrEvent, type?: ReadListTags): ProfilePointer[];
+/**
+ * Returns a deduplicated array of all 'relay' tags in a list or set
+ * @param list - The list or set to get the relays from
+ * @param type - Which types of tags to read
+ */
+export declare function getRelaysFromList(list: NostrEvent, type?: ReadListTags): string[];
+/** Returns if an event is a valid list or set */
+export declare function isValidList(event: NostrEvent): boolean;

package/dist/helpers/lists.js

@@ -0,0 +1,110 @@
+import { getReplaceableIdentifier, isAddressableKind, isReplaceable, isReplaceableKind, } from "applesauce-core/helpers/event";
+import { getHiddenTags } from "applesauce-core/helpers/hidden-tags";
+import { getAddressPointerForEvent, getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "applesauce-core/helpers/pointers";
+import { mergeRelaySets } 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) {
+        case "public":
+            return list.tags;
+        case "hidden":
+            return getHiddenTags(list) ?? [];
+        default:
+        case "all":
+            return [...(getHiddenTags(list) ?? []), ...list.tags];
+    }
+}
+/**
+ * Checks if an event pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in EventPointer
+ * @param list - The list or set to check
+ * @param pointer - The event pointer to check
+ * @param type - Which types of tags to check
+ */
+export function isEventPointerInList(list, pointer, type) {
+    const id = typeof pointer === "string" ? pointer : pointer.id;
+    const tags = getListTags(list, type);
+    return tags.some((t) => t[0] === "e" && t[1] === id);
+}
+/**
+ * Checks if an address pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in AddressPointer
+ * @param list - The list or set to check
+ * @param pointer - The address pointer to check
+ * @param type - Which types of tags to check
+ */
+export function isAddressPointerInList(list, pointer, type) {
+    const cord = typeof pointer === "string" ? pointer : getCoordinateFromAddressPointer(pointer);
+    const tags = getListTags(list, type);
+    return tags.some((t) => t[0] === "a" && t[1] === cord);
+}
+/**
+ * Checks if an profile pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in ProfilePointer
+ * @param list - The list or set to check
+ * @param pointer - The profile pointer to check
+ * @param type - Which types of tags to check
+ */
+export function isProfilePointerInList(list, pointer, type) {
+    const pubkey = typeof pointer === "string" ? pointer : pointer.pubkey;
+    const tags = getListTags(list, type);
+    return tags.some((t) => t[0] === "p" && t[1] === pubkey);
+}
+/** Returns if an event is in a list */
+export function isEventInList(list, event) {
+    return isReplaceable(event.kind)
+        ? isAddressPointerInList(list, getAddressPointerForEvent(event))
+        : isEventPointerInList(list, event);
+}
+/**
+ * Returns all the EventPointer in a list or set
+ * @param list - The list or set to get the event pointers from
+ * @param type - Which types of tags to read
+ */
+export function getEventPointersFromList(list, type) {
+    return processTags(getListTags(list, type), (tag) => (isETag(tag) ? tag : undefined), getEventPointerFromETag);
+}
+/**
+ * Returns all the AddressPointer in a list or set
+ * @param list - The list or set to get the address pointers from
+ * @param type - Which types of tags to read
+ */
+export function getAddressPointersFromList(list, type) {
+    return processTags(getListTags(list, type), (t) => (isATag(t) ? t : undefined), getAddressPointerFromATag);
+}
+/**
+ * Returns all the ProfilePointer in a list or set
+ * @param list - The list or set to get the profile pointers from
+ * @param type - Which types of tags to read
+ */
+export function getProfilePointersFromList(list, type) {
+    return processTags(getListTags(list, type), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag);
+}
+/**
+ * Returns a deduplicated array of all 'relay' tags in a list or set
+ * @param list - The list or set to get the relays from
+ * @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)));
+}
+/** Returns if an event is a valid list or set */
+export function isValidList(event) {
+    try {
+        if (isAddressableKind(event.kind)) {
+            // event is a set
+            // ensure the set has an identifier
+            if (!getReplaceableIdentifier(event))
+                return false;
+            return true;
+        }
+        else if (isReplaceableKind(event.kind) && event.kind >= 10000 && event.kind < 20000) {
+            // event is a list
+            return true;
+        }
+    }
+    catch (error) { }
+    return false;
+}

package/dist/helpers/lnurl.d.ts

@@ -0,0 +1,8 @@
+/** Parses a lightning address (lud16) into a LNURLp */
+export declare function parseLightningAddress(address: string): URL | undefined;
+/** Parses a LNURLp into a URL */
+export declare function decodeLNURL(lnurl: string): URL | undefined;
+/** Parses a lightning address or LNURLp into a URL */
+export declare function parseLNURLOrAddress(addressOrLNURL: string): URL | undefined;
+/** Requests a bolt11 invoice from a LNURLp callback URL */
+export declare function getInvoice(callback: URL): Promise<string>;

package/dist/helpers/lnurl.js

@@ -0,0 +1,44 @@
+import { bech32 } from "@scure/base";
+import { parseBolt11 } from "./bolt11.js";
+const decoder = new TextDecoder();
+/** Parses a lightning address (lud16) into a LNURLp */
+export function parseLightningAddress(address) {
+    let [name, domain] = address.split("@");
+    if (!name || !domain)
+        return;
+    return new URL(`https://${domain}/.well-known/lnurlp/${name}`);
+}
+/** Parses a LNURLp into a URL */
+export function decodeLNURL(lnurl) {
+    try {
+        const { words, prefix } = bech32.decode(lnurl);
+        if (prefix !== "lnurl")
+            return;
+        const str = decoder.decode(bech32.fromWords(words));
+        return new URL(str);
+    }
+    catch (error) { }
+    return undefined;
+}
+/** Parses a lightning address or LNURLp into a URL */
+export function parseLNURLOrAddress(addressOrLNURL) {
+    if (addressOrLNURL.includes("@"))
+        return parseLightningAddress(addressOrLNURL);
+    else
+        return decodeLNURL(addressOrLNURL);
+}
+/** Requests a bolt11 invoice from a LNURLp callback URL */
+export async function getInvoice(callback) {
+    const { pr: payRequest } = await fetch(callback).then((res) => res.json());
+    const amount = callback.searchParams.get("amount");
+    if (!amount)
+        throw new Error("Missing amount");
+    if (payRequest) {
+        const parsed = parseBolt11(payRequest);
+        if (parsed.amount !== parseInt(amount))
+            throw new Error("Incorrect amount");
+        return payRequest;
+    }
+    else
+        throw new Error("Failed to get invoice");
+}

package/dist/helpers/mailboxes.d.ts

@@ -0,0 +1,7 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+export declare const MailboxesInboxesSymbol: unique symbol;
+export declare const MailboxesOutboxesSymbol: unique symbol;
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
+export declare function getInboxes(event: NostrEvent): string[];
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
+export declare function getOutboxes(event: NostrEvent): string[];

package/dist/helpers/mailboxes.js

@@ -0,0 +1,49 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { isSafeRelayURL } from "applesauce-core/helpers/relays";
+import { isRTag } from "applesauce-core/helpers/tags";
+import { normalizeURL } from "applesauce-core/helpers/url";
+export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
+export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
+export function getInboxes(event) {
+    return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
+        const inboxes = [];
+        for (const tag of event.tags) {
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [, url, mode] = tag;
+                if (url && isSafeRelayURL(url) && !inboxes.includes(url) && (mode === "read" || mode === undefined)) {
+                    inboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
+            }
+        }
+        return inboxes;
+    });
+}
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
+export function getOutboxes(event) {
+    return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
+        const outboxes = [];
+        for (const tag of event.tags) {
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [name, url, mode] = tag;
+                if (name === "r" &&
+                    isSafeRelayURL(url) &&
+                    !outboxes.includes(url) &&
+                    (mode === "write" || mode === undefined)) {
+                    outboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
+            }
+        }
+        return outboxes;
+    });
+}