applesauce-common 0.0.0-next-20251203172109

package/dist/helpers/reports.d.ts

@@ -0,0 +1,28 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+export declare const ParsedReportSymbol: unique symbol;
+export declare enum ReportReason {
+    nudity = "nudity",
+    malware = "malware",
+    profanity = "profanity",
+    illegal = "illegal",
+    spam = "spam",
+    impersonation = "impersonation",
+    other = "other"
+}
+export type ReportedUser = {
+    type: "user";
+    event: NostrEvent;
+    pubkey: string;
+    reason?: ReportReason;
+};
+export type ReportedEvent = {
+    type: "event";
+    event: NostrEvent;
+    comment?: string;
+    id: string;
+    pubkey: string;
+    reason?: ReportReason;
+    blobs?: string[];
+};
+/** Reads a report event as either a user or event report */
+export declare function getReported(report: NostrEvent): ReportedEvent | ReportedUser;

package/dist/helpers/reports.js

@@ -0,0 +1,38 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { isETag, isPTag } from "applesauce-core/helpers/tags";
+export const ParsedReportSymbol = Symbol("parsed-report");
+export var ReportReason;
+(function (ReportReason) {
+    ReportReason["nudity"] = "nudity";
+    ReportReason["malware"] = "malware";
+    ReportReason["profanity"] = "profanity";
+    ReportReason["illegal"] = "illegal";
+    ReportReason["spam"] = "spam";
+    ReportReason["impersonation"] = "impersonation";
+    ReportReason["other"] = "other";
+})(ReportReason || (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 comment = report.content ? report.content.trim() : undefined;
+        const e = report.tags.find(isETag);
+        // Event report
+        if (e) {
+            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],
+                blobs,
+            };
+        }
+        // User report
+        return { type: "user", event: report, comment, pubkey: p[1], reason: p[2] };
+    });
+}

package/dist/helpers/share.d.ts

@@ -0,0 +1,19 @@
+import { KnownEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+import { kinds, NostrEvent } from "applesauce-core/helpers/event";
+/** Type of a known share event */
+export type ShareEvent = KnownEvent<kinds.Repost | kinds.GenericRepost>;
+export declare const SharedEventSymbol: unique symbol;
+export declare const SharedEventPointerSymbol: unique symbol;
+export declare const SharedAddressPointerSymbol: unique symbol;
+/** Returns the event pointer of a kind 6 or 16 share event */
+export declare function getSharedEventPointer(event: ShareEvent): EventPointer;
+export declare function getSharedEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Returns the address pointer of a kind 6 or 16 share event */
+export declare function getSharedAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Returns the stringified event in the content of a kind 6 or 16 share event */
+export declare function getEmbededSharedEvent(event: NostrEvent): NostrEvent | undefined;
+/** @deprecated use getEmbededSharedEvent instead */
+export declare const parseSharedEvent: typeof getEmbededSharedEvent;
+/** Validates that an event is a valid share event */
+export declare function isValidShare(event?: NostrEvent): event is ShareEvent;

package/dist/helpers/share.js

@@ -0,0 +1,58 @@
+import { getOrComputeCachedValue, isEvent, safeParse, verifyWrappedEvent } from "applesauce-core/helpers";
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getAddressPointerFromATag, getEventPointerFromETag, } from "applesauce-core/helpers/pointers";
+import { isATag, isETag } from "applesauce-core/helpers/tags";
+import { kinds } from "applesauce-core/helpers/event";
+export const SharedEventSymbol = Symbol.for("shared-event");
+export const SharedEventPointerSymbol = Symbol.for("shared-event-pointer");
+export const SharedAddressPointerSymbol = Symbol.for("shared-address-pointer");
+export function getSharedEventPointer(event) {
+    return getOrComputeCachedValue(event, SharedEventPointerSymbol, () => {
+        const e = event.tags.find(isETag);
+        if (!e)
+            return undefined;
+        // Get kind from k tag if it exists
+        const kStr = getTagValue(event, "k");
+        const k = kStr ? parseInt(kStr) : undefined;
+        const pointer = getEventPointerFromETag(e);
+        if (k !== undefined)
+            pointer.kind = k;
+        return pointer;
+    });
+}
+/** Returns the address pointer of a kind 6 or 16 share event */
+export function getSharedAddressPointer(event) {
+    return getOrComputeCachedValue(event, SharedAddressPointerSymbol, () => {
+        const a = event.tags.find(isATag);
+        if (!a)
+            return undefined;
+        return getAddressPointerFromATag(a);
+    });
+}
+/** Returns the stringified event in the content of a kind 6 or 16 share event */
+export function getEmbededSharedEvent(event) {
+    return getOrComputeCachedValue(event, SharedEventSymbol, () => {
+        const pointer = getSharedEventPointer(event);
+        if (pointer === undefined || event.content === "")
+            return undefined;
+        const sharedEvent = safeParse(event.content);
+        // Ensure event is a valid Nostr event
+        if (!isEvent(sharedEvent))
+            return undefined;
+        // Ensure event id matches the pointer
+        if (sharedEvent.id !== pointer.id)
+            return undefined;
+        // Ensure event is verified
+        if (!verifyWrappedEvent(sharedEvent))
+            return undefined;
+        return sharedEvent;
+    });
+}
+/** @deprecated use getEmbededSharedEvent instead */
+export const parseSharedEvent = getEmbededSharedEvent;
+/** Validates that an event is a valid share event */
+export function isValidShare(event) {
+    if (!event)
+        return false;
+    return ((event.kind === kinds.Repost || event.kind === kinds.GenericRepost) && getSharedEventPointer(event) !== undefined);
+}

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

@@ -0,0 +1,4 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+/** Returns the pointer to the stream chat message stream */
+export declare function getStreamChatMessageStream(message: NostrEvent): AddressPointer | undefined;

package/dist/helpers/stream-chat.js

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

package/dist/helpers/stream.d.ts

@@ -0,0 +1,31 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { EventPointer, ProfilePointer } from "applesauce-core/helpers/pointers";
+export type StreamStatus = "live" | "ended" | "planned";
+export type StreamRole = "host" | "participant" | "speaker";
+export declare function getStreamTitle(stream: NostrEvent): string | undefined;
+export declare function getStreamSummary(stream: NostrEvent): string | undefined;
+export declare function getStreamImage(stream: NostrEvent): string | undefined;
+/** Returns the status of the stream, defaults to ended if the stream is older than 2 weeks */
+export declare function getStreamStatus(stream: NostrEvent): StreamStatus;
+/** Returns the pubkey of the host of the stream */
+export declare function getStreamHost(stream: NostrEvent): ProfilePointer;
+/** Returns the participants of a stream */
+export declare function getStreamParticipants(stream: NostrEvent): (ProfilePointer & {
+    role: StreamRole;
+})[];
+export declare function getStreamGoalPointer(stream: NostrEvent): EventPointer | undefined;
+/** Gets all the streaming urls for a stream */
+export declare function getStreamStreamingURLs(stream: NostrEvent): string[];
+export declare function getStreamRecording(stream: NostrEvent): string | undefined;
+/** Gets the relays for a stream */
+export declare function getStreamRelays(stream: NostrEvent): string[] | undefined;
+/** Gets the stream start time if it has one */
+export declare function getStreamStartTime(stream: NostrEvent): number | undefined;
+/** Gets the stream end time if it has one */
+export declare function getStreamEndTime(stream: NostrEvent): number | undefined;
+/** Returns the current number of participants in the stream */
+export declare function getStreamViewers(stream: NostrEvent): number | undefined;
+/** Returns the maximum number of participants in the stream */
+export declare function getStreamMaxViewers(stream: NostrEvent): number | undefined;
+/** Returns the hashtags for a stream */
+export declare function getStreamHashtags(stream: NostrEvent): string[];

package/dist/helpers/stream.js

@@ -0,0 +1,81 @@
+import { getTagValue } from "applesauce-core/helpers/event";
+import { addRelayHintsToPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "applesauce-core/helpers/pointers";
+import { mergeRelaySets } from "applesauce-core/helpers/relays";
+import { isPTag } from "applesauce-core/helpers/tags";
+import { unixNow } from "applesauce-core/helpers/time";
+export function getStreamTitle(stream) {
+    return getTagValue(stream, "title");
+}
+export function getStreamSummary(stream) {
+    return getTagValue(stream, "summary");
+}
+export function getStreamImage(stream) {
+    return getTagValue(stream, "image");
+}
+const TWO_WEEKS = 60 * 60 * 24 * 14;
+/** Returns the status of the stream, defaults to ended if the stream is older than 2 weeks */
+export function getStreamStatus(stream) {
+    if (stream.created_at < unixNow() - TWO_WEEKS)
+        return "ended";
+    else
+        return getTagValue(stream, "status") || "ended";
+}
+/** Returns the pubkey of the host of the stream */
+export function getStreamHost(stream) {
+    let host = undefined;
+    for (const tag of stream.tags) {
+        if (isPTag(tag) && (!host || (tag[3] && tag[3].toLowerCase() === "host"))) {
+            host = getProfilePointerFromPTag(tag);
+        }
+    }
+    return host || { pubkey: stream.pubkey };
+}
+/** Returns the participants of a stream */
+export function getStreamParticipants(stream) {
+    return stream.tags
+        .filter((t) => isPTag(t) && t[3])
+        .map((t) => ({ ...getProfilePointerFromPTag(t), role: t[3].toLowerCase() }));
+}
+export function getStreamGoalPointer(stream) {
+    const goalTag = stream.tags.find((t) => t[0] === "goal");
+    return goalTag && addRelayHintsToPointer(getEventPointerFromETag(goalTag), getStreamRelays(stream));
+}
+/** Gets all the streaming urls for a stream */
+export function getStreamStreamingURLs(stream) {
+    return stream.tags.filter((t) => t[0] === "streaming").map((t) => t[1]);
+}
+export function getStreamRecording(stream) {
+    return getTagValue(stream, "recording");
+}
+/** Gets the relays for a stream */
+export function getStreamRelays(stream) {
+    for (const tag of stream.tags) {
+        if (tag[0] === "relays")
+            return mergeRelaySets(tag.slice(1));
+    }
+    return undefined;
+}
+/** Gets the stream start time if it has one */
+export function getStreamStartTime(stream) {
+    const str = getTagValue(stream, "starts");
+    return str ? parseInt(str) : undefined;
+}
+/** Gets the stream end time if it has one */
+export function getStreamEndTime(stream) {
+    const str = getTagValue(stream, "ends");
+    return str ? parseInt(str) : getStreamStatus(stream) === "ended" ? stream.created_at : undefined;
+}
+/** Returns the current number of participants in the stream */
+export function getStreamViewers(stream) {
+    const viewers = getTagValue(stream, "current_participants");
+    return viewers ? parseInt(viewers) : undefined;
+}
+/** Returns the maximum number of participants in the stream */
+export function getStreamMaxViewers(stream) {
+    const viewers = getTagValue(stream, "total_participants");
+    return viewers ? parseInt(viewers) : undefined;
+}
+/** Returns the hashtags for a stream */
+export function getStreamHashtags(stream) {
+    return stream.tags.filter((t) => t[0] === "t").map((t) => t[1]);
+}

package/dist/helpers/threading.d.ts

@@ -0,0 +1,55 @@
+import { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+export type ThreadReferences = {
+    root?: {
+        e: EventPointer;
+        a: undefined;
+    } | {
+        e: undefined;
+        a: AddressPointer;
+    } | {
+        e: EventPointer;
+        a: AddressPointer;
+    };
+    reply?: {
+        e: EventPointer;
+        a: undefined;
+    } | {
+        e: undefined;
+        a: AddressPointer;
+    } | {
+        e: EventPointer;
+        a: AddressPointer;
+    };
+};
+export declare const Nip10ThreadRefsSymbol: unique symbol;
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export declare function getEventPointerFromThreadTag(tag: string[]): EventPointer;
+/** Parses NIP-10 tags and handles legacy behavior */
+export declare function interpretThreadTags(tags: string[][]): {
+    root?: {
+        e: string[];
+        a: undefined;
+    } | {
+        e: undefined;
+        a: string[];
+    } | {
+        e: string[];
+        a: string[];
+    };
+    reply?: {
+        e: string[];
+        a: undefined;
+    } | {
+        e: undefined;
+        a: string[];
+    } | {
+        e: string[];
+        a: string[];
+    };
+};
+/** Returns the parsed NIP-10 tags for an event */
+export declare function getNip10References(event: NostrEvent | EventTemplate): ThreadReferences;

package/dist/helpers/threading.js

@@ -0,0 +1,94 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getAddressPointerFromATag } from "applesauce-core/helpers/pointers";
+import { isSafeRelayURL } from "applesauce-core/helpers/relays";
+export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export function getEventPointerFromThreadTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2] && isSafeRelayURL(tag[2]))
+        pointer.relays = [tag[2]];
+    // get author from NIP-18 quote tags, nip-22 comments tags, or nip-10 thread tags
+    if (tag[0] === "e" &&
+        (tag[3] === "root" || tag[3] === "reply" || tag[3] === "mention") &&
+        tag[4] &&
+        tag[4].length === 64) {
+        // NIP-10 "e" tag
+        pointer.author = tag[4];
+    }
+    return pointer;
+}
+/** Parses NIP-10 tags and handles legacy behavior */
+export function interpretThreadTags(tags) {
+    const eTags = tags.filter((t) => t[0] === "e" && t[1]);
+    const aTags = tags.filter((t) => t[0] === "a" && t[1]);
+    // find the root and reply tags.
+    let rootETag = eTags.find((t) => t[3] === "root");
+    let replyETag = eTags.find((t) => t[3] === "reply");
+    let rootATag = aTags.find((t) => t[3] === "root");
+    let replyATag = aTags.find((t) => t[3] === "reply");
+    if (!rootETag || !replyETag) {
+        // a direct reply does not need a "reply" reference
+        // https://github.com/nostr-protocol/nips/blob/master/10.md
+        // this is not necessarily to spec. but if there is only one id (root or reply) then assign it to both
+        // this handles the cases where a client only set a "reply" tag and no root
+        rootETag = replyETag = rootETag || replyETag;
+    }
+    if (!rootATag || !replyATag) {
+        rootATag = replyATag = rootATag || replyATag;
+    }
+    if (!rootETag && !replyETag) {
+        // legacy behavior
+        // https://github.com/nostr-protocol/nips/blob/master/10.md#positional-e-tags-deprecated
+        const legacyETags = eTags.filter((t) => {
+            // ignore it if there is a marker
+            if (t[3])
+                return false;
+            return true;
+        });
+        if (legacyETags.length >= 1) {
+            // first tag is the root
+            rootETag = legacyETags[0];
+            // last tag is reply
+            replyETag = legacyETags[legacyETags.length - 1] ?? rootETag;
+        }
+    }
+    return {
+        root: rootETag || rootATag ? { e: rootETag, a: rootATag } : undefined,
+        reply: replyETag || replyATag ? { e: replyETag, a: replyATag } : undefined,
+    };
+}
+/** Returns the parsed NIP-10 tags for an event */
+export function getNip10References(event) {
+    return getOrComputeCachedValue(event, Nip10ThreadRefsSymbol, () => {
+        const tags = interpretThreadTags(event.tags);
+        let root;
+        if (tags.root) {
+            try {
+                root = {
+                    e: tags.root.e && getEventPointerFromThreadTag(tags.root.e),
+                    a: tags.root.a && getAddressPointerFromATag(tags.root.a),
+                };
+            }
+            catch (error) { }
+        }
+        let reply;
+        if (tags.reply) {
+            try {
+                reply = {
+                    e: tags.reply.e && getEventPointerFromThreadTag(tags.reply.e),
+                    a: tags.reply.a && getAddressPointerFromATag(tags.reply.a),
+                };
+            }
+            catch (error) { }
+        }
+        return {
+            root,
+            reply,
+        };
+    });
+}

package/dist/helpers/torrent.d.ts

@@ -0,0 +1,55 @@
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+export declare const TORRENT_KIND = 2003;
+/** Type for validated torrent events */
+export type TorrentEvent = KnownEvent<typeof TORRENT_KIND>;
+/** A file entry inside a torrent */
+export type TorrentFile = {
+    /** Full path of the file, e.g., "info/example.txt" */
+    name: string;
+    /** Size of the file in bytes (optional) */
+    size?: number;
+};
+/** Supported external identifier prefixes for torrents (excluding tcat and newznab, which are handled separately) */
+export type TorrentExternalIdentifierPrefix = "tmdb" | "ttvdb" | "imdb" | "mal" | "anilist";
+/** External identifier for a torrent */
+export type TorrentExternalIdentifier = {
+    /** The prefix type */
+    prefix: TorrentExternalIdentifierPrefix;
+    /** The full identifier string (e.g., "tmdb:movie:693134") */
+    identifier: string;
+    /** For second-level prefixes, the media type (e.g., "movie", "anime", "manga") */
+    mediaType?: string;
+    /** The ID part of the identifier */
+    id: string;
+};
+/** Returns the BitTorrent info hash from the `x` tag */
+export declare function getTorrentInfoHash(torrent: TorrentEvent): string;
+export declare function getTorrentInfoHash(torrent: NostrEvent): string | undefined;
+/** Returns the torrent title from the `title` tag */
+export declare function getTorrentTitle(torrent: NostrEvent): string | undefined;
+/** Returns all file entries from `file` tags */
+export declare function getTorrentFiles(torrent: NostrEvent): TorrentFile[];
+/** Returns all tracker URLs from `tracker` tags */
+export declare function getTorrentTrackers(torrent: NostrEvent): string[];
+/** Returns the newznab category ID from the `i` tag with `newznab:` prefix */
+export declare function getTorrentCategory(torrent: NostrEvent): number | undefined;
+/** Returns all search tags (for searchability) from `t` tags */
+export declare function getTorrentSearchTags(torrent: NostrEvent): string[];
+/** Returns the category path from the `tcat` identifier in `i` tags (e.g., "video,movie,4k") */
+export declare function getTorrentCategoryPath(torrent: NostrEvent): string | undefined;
+/** Returns all external identifiers from `i` tags (excluding tcat and newznab, which are handled separately) */
+export declare function getTorrentExternalIdentifiers(torrent: NostrEvent): TorrentExternalIdentifier[];
+/**
+ * Creates a TorrentExternalIdentifier object from prefix, id, and optional mediaType
+ * Automatically constructs the full identifier string
+ */
+export declare function createTorrentExternalIdentifier(prefix: TorrentExternalIdentifierPrefix, id: string, mediaType?: string): TorrentExternalIdentifier;
+/**
+ * Builds a magnet link from an info hash, optional trackers, and optional name
+ * Format: magnet:?xt=urn:btih:${infoHash}${trackers ? '&tr=' + trackers.join('&tr=') : ''}${name ? '&dn=' + encodeURIComponent(name) : ''}
+ */
+export declare function buildTorrentMagnetLink(infoHash: string, trackers?: string[], name?: string): string;
+/** Returns the magnet link for a torrent, building it from the event if needed */
+export declare function getTorrentMagnetLink(torrent: NostrEvent): string | undefined;
+/** Validates that an event is a valid torrent event (kind 2003 with required `x` tag) */
+export declare function isValidTorrent(torrent: NostrEvent): torrent is TorrentEvent;