transcriptify 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# `Transcriptify`
+
+[![npm](https://img.shields.io/npm/dw/Transcriptify)](http://npmjs.org/package/Transcriptify)
+![GitHub package.json version](https://img.shields.io/github/package-json/v/dev-hoehle/transcriptify)
+![GitHub Repo stars](https://img.shields.io/github/stars/dev-hoehle/transcriptify?style=social)
+
+
+> Generate beautiful, secure HTML transcripts from Discord channels.
+
+- **Parses Discord formatting**: preserves markdown (bold, italics, code, strikethrough), mentions, and embeds.
+- **Attachment-friendly**: renders images, videos, audio and files with optional asset saving.
+- **Safe by default**: built‑in XSS protection and sanitization.
+- **Themeable output**: client-side themes and optional theme switching.
+- **Simple API**: `import { createTranscript } from 'transcriptify'` — call `createTranscript(channel, options)`.
+- **discord.js support**: works with v14 and v15.
+
+## Quickstart
+
+Install (for local/dev usage):
+
+```bash
+npm i transcriptify
+```
+
+Create a `.env` with your bot token:
+
+```
+TOKEN=your_bot_token_here
+```
+
+Example ussage:
+```ts
+import * as discord from "discord.js";
+import { config } from "dotenv";
+import { createTranscript } from "transcriptify";
+
+config();
+
+const { Guilds, GuildMessages, MessageContent } = discord.GatewayIntentBits;
+
+const client = new discord.Client({ intents: [Guilds, GuildMessages, MessageContent] });
+
+client.on("ready", async () => {
+    console.log("Logged in as", client.user?.tag);
+
+    const channel = await client.channels.fetch("1469427183960199470");
+    if (!channel || !channel.isTextBased()) {
+        console.error("Invalid channel provided.");
+        process.exit(1);
+    }
+
+    console.time("transcript");
+    const attachment = await createTranscript(channel, {
+        filename: "test-transcript.html",
+    });
+
+    console.timeEnd("transcript");
+
+    console.log("✓ Generated:", attachment?.name ?? attachment);
+    await client.destroy();
+    process.exit(0);
+});
+
+client.login(process.env.TOKEN as string);
+```
+
+See the docs for a short usage guide and options: [docs/usage.md](https://github.com/dev-hoehle/transcriptify/docs/usage.md).
+
+Preview:
+
+![preview](https://raw.githubusercontent.com/dev-hoehle/transcriptify/docs/assets/preview.gif)
+
+## Credits
+
+- Inspired by: [ItzDerock/discord-html-transcripts](https://github.com/ItzDerock/discord-html-transcripts)
+- Design / UI suggestions: GitHub Copilot
+
+License: MIT — see [LICENSE](LICENSE)

package/dist/src/generateHtml.d.ts

@@ -0,0 +1,3 @@
+import type { ExportableTranscript } from "../types/exportableTranscript";
+import { TranscriptCreateOptions } from "../types/general";
+export declare function generateHtml(transcript: ExportableTranscript, options?: TranscriptCreateOptions): Promise<string>;

package/dist/src/generateHtml.js

@@ -0,0 +1,303 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHtml = generateHtml;
+const react_1 = __importDefault(require("react"));
+const server_1 = __importDefault(require("react-dom/server"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const Transcript_1 = __importDefault(require("./web/discord-components/Transcript"));
+const assetManager_1 = require("./utils/assetManager");
+const esbuild_1 = __importDefault(require("esbuild"));
+function TranscriptSSRWrapper(props) {
+    return react_1.default.createElement(Transcript_1.default, {
+        channel: props.channel,
+        messages: props.messages,
+        theme: props.theme,
+        allowThemeSwitching: props.allowThemeSwitching,
+        allowThemeSwitchingPersist: props.allowThemeSwitchingPersist,
+        poweredBy: props.poweredBy,
+        className: props.className || "",
+        resolvedUsers: props.resolvedUsers,
+        resolvedRoles: props.resolvedRoles,
+        resolvedChannels: props.resolvedChannels,
+        exportedAt: props.exportedAt
+    });
+}
+function buildHtmlDocument(content, transcriptData, clientCode) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Discord Transcript</title>
+	<script src="https://cdn.tailwindcss.com"></script>
+	<style id="app-css">[APP_CSS]</style>
+	<style id="highlight-css">[HIGHLIGHT_CSS]</style>
+	<script>window.__TRANSCRIPT_DATA__=${transcriptData};</script>
+</head>
+<body>
+	<div id="root">${content}</div>
+	<script type="module">${clientCode}</script>
+</body>
+</html>`;
+}
+async function generateHtml(transcript, options = {}) {
+    const { filename, poweredBy = true, allowThemeSwitching = true, theme = "dark", ignore = {} } = options;
+    const channelInfo = {
+        name: transcript.meta.channelName || "transcript",
+        topic: undefined,
+        id: transcript.meta.channelId,
+        guildId: transcript.meta.guildId ?? null
+    };
+    const messages = transcript.messages.filter((msg) => {
+        const authorId = typeof msg.author === "string" ? msg.author : null;
+        if (authorId && Array.isArray(ignore?.userIDs) && ignore.userIDs.includes(authorId))
+            return false;
+        if (ignore?.bots) {
+            const resolved = transcript.resolvedUsers || {};
+            const authorData = authorId ? resolved[authorId] : null;
+            if (authorData?.bot)
+                return false;
+        }
+        return true;
+    });
+    let processedMessages = messages;
+    let transcriptDataToProcess = null;
+    let assetManager = null;
+    const saveOpt = options.saveAssets ?? options.saveImages;
+    if (!saveOpt) {
+        try {
+            if (transcript.resolvedUsers && typeof transcript.resolvedUsers === "object") {
+                for (const [uid, u] of Object.entries(transcript.resolvedUsers)) {
+                    try {
+                        const user = u;
+                        if (user && typeof user.avatar === "string" && !/^https?:\/\//i.test(user.avatar) && !/^assets\//.test(user.avatar)) {
+                            const isAnimated = user.avatar.startsWith("a_");
+                            const ext = isAnimated ? ".gif" : ".png";
+                            user.avatar = `https://cdn.discordapp.com/avatars/${uid}/${user.avatar}${ext}?size=128`;
+                        }
+                        if (user &&
+                            user.guildTag &&
+                            user.guildTag.iconUrl &&
+                            typeof user.guildTag.iconUrl === "string" &&
+                            !/^https?:\/\//i.test(user.guildTag.iconUrl) &&
+                            !/^assets\//.test(user.guildTag.iconUrl)) {
+                            user.guildTag.iconUrl = `https://cdn.discordapp.com/guilds/${user.guildTag.id || "0"}/icons/${user.guildTag.iconUrl}.png`;
+                        }
+                    }
+                    catch (e) { }
+                }
+            }
+            if (Array.isArray(messages)) {
+                for (const m of messages) {
+                    if (m && Array.isArray(m.stickers)) {
+                        for (const st0 of m.stickers) {
+                            try {
+                                const st = st0;
+                                if (st && typeof st === "object") {
+                                    const id = st.id || st.sticker_id || st.assetId || null;
+                                    if (id && !st.url) {
+                                        st.url = `https://media.discordapp.net/stickers/${id}.webp?size=160&quality=lossless`;
+                                    }
+                                }
+                            }
+                            catch (e) { }
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) { }
+    }
+    if (saveOpt) {
+        const compression = typeof saveOpt === "object" && typeof saveOpt.compression === "number" ? saveOpt.compression : undefined;
+        const assetsDirOption = typeof saveOpt === "object" && typeof saveOpt.dir === "string" ? saveOpt.dir : "assets";
+        const assetsDir = path_1.default.isAbsolute(assetsDirOption) ? assetsDirOption : path_1.default.join(process.cwd(), assetsDirOption);
+        assetManager = new assetManager_1.AssetManager(assetsDir, { compression });
+        await assetManager.initialize();
+        transcriptDataToProcess = JSON.parse(JSON.stringify({
+            messages: processedMessages,
+            resolvedUsers: transcript.resolvedUsers,
+            resolvedRoles: transcript.resolvedRoles,
+            meta: transcript.meta
+        }));
+        if (transcriptDataToProcess.resolvedUsers && typeof transcriptDataToProcess.resolvedUsers === "object") {
+            for (const [uid, u] of Object.entries(transcriptDataToProcess.resolvedUsers)) {
+                try {
+                    const user = u;
+                    if (user && typeof user.avatar === "string" && !/^https?:\/\//i.test(user.avatar)) {
+                        const isAnimated = user.avatar.startsWith("a_");
+                        const ext = isAnimated ? ".gif" : ".png";
+                        user.avatar = `https://cdn.discordapp.com/avatars/${uid}/${user.avatar}${ext}?size=128`;
+                    }
+                    if (user &&
+                        user.guildTag &&
+                        user.guildTag.iconUrl &&
+                        typeof user.guildTag.iconUrl === "string" &&
+                        !/^https?:\/\//i.test(user.guildTag.iconUrl)) {
+                        user.guildTag.iconUrl = `https://cdn.discordapp.com/guilds/${user.guildTag.id || "0"}/icons/${user.guildTag.iconUrl}.png`;
+                    }
+                }
+                catch (e) { }
+            }
+        }
+        if (Array.isArray(transcriptDataToProcess.messages)) {
+            for (const m of transcriptDataToProcess.messages) {
+                if (m && Array.isArray(m.stickers)) {
+                    for (const st of m.stickers) {
+                        try {
+                            if (st && typeof st === "object") {
+                                const id = st.id || st.sticker_id || st.assetId || null;
+                                if (id && !st.url) {
+                                    st.url = `https://media.discordapp.net/stickers/${id}.webp?size=160&quality=lossless`;
+                                }
+                            }
+                        }
+                        catch (e) { }
+                    }
+                }
+            }
+        }
+        await assetManager.downloadAssets(transcriptDataToProcess);
+        transcriptDataToProcess = assetManager.replaceUrls(transcriptDataToProcess);
+        processedMessages = transcriptDataToProcess.messages;
+    }
+    const resolvedTheme = (theme === "system" ? "dark" : theme);
+    const props = {
+        channel: channelInfo,
+        messages: processedMessages,
+        theme: resolvedTheme,
+        allowThemeSwitching,
+        allowThemeSwitchingPersist: true,
+        poweredBy: poweredBy,
+        className: "transcript-ssr"
+    };
+    let resolvedUsers = transcript.resolvedUsers || {};
+    let resolvedRoles = transcript.resolvedRoles || {};
+    let resolvedChannels = transcript.resolvedChannels || {};
+    if (transcriptDataToProcess) {
+        resolvedUsers = transcriptDataToProcess.resolvedUsers || resolvedUsers;
+        resolvedRoles = transcriptDataToProcess.resolvedRoles || resolvedRoles;
+        resolvedChannels = transcriptDataToProcess.resolvedChannels || resolvedChannels;
+    }
+    try {
+        const stripped = {};
+        for (const k of Object.keys(resolvedChannels || {})) {
+            const v = resolvedChannels[k];
+            if (v && typeof v === "object")
+                stripped[k] = { name: v.name ?? null };
+            else
+                stripped[k] = { name: v?.name ?? null };
+        }
+        resolvedChannels = stripped;
+    }
+    catch (e) { }
+    let effectiveResolvedUsers = resolvedUsers;
+    if (ignore?.guildBadges) {
+        effectiveResolvedUsers = {};
+        for (const k of Object.keys(resolvedUsers)) {
+            const v = resolvedUsers[k];
+            if (v && typeof v === "object") {
+                const { guildTag, ...rest } = v;
+                effectiveResolvedUsers[k] = rest;
+            }
+            else {
+                effectiveResolvedUsers[k] = v;
+            }
+        }
+    }
+    const ssrProps = Object.assign({}, props, {
+        resolvedUsers: effectiveResolvedUsers,
+        resolvedRoles,
+        resolvedChannels,
+        exportedAt: transcript.meta.generatedAt
+    });
+    const _origConsoleError = console.error;
+    console.error = (...args) => {
+        try {
+            const msg = String(args && args.length ? args[0] : "");
+            if (msg && msg.includes('Each child in a list should have a unique "key" prop')) {
+                const stack = new Error().stack || "";
+                const out = `=== React Key Warning ===\nMessage: ${msg}\nArgs:${JSON.stringify(args.slice(1), null, 2)}\nStack:${stack}\n\n`;
+                try {
+                    promises_1.default.appendFile(path_1.default.join(process.cwd(), ".react-key-warning.log"), out, "utf-8");
+                }
+                catch (e) { }
+            }
+        }
+        catch (e) { }
+        return _origConsoleError.apply(console, args);
+    };
+    const content = server_1.default.renderToString(react_1.default.createElement(TranscriptSSRWrapper, ssrProps));
+    console.error = _origConsoleError;
+    const transcriptData = JSON.stringify({
+        channel: channelInfo,
+        messages: processedMessages,
+        theme: resolvedTheme,
+        allowThemeSwitching: allowThemeSwitching,
+        allowThemeSwitchingPersist: true,
+        resolvedUsers: effectiveResolvedUsers,
+        resolvedRoles,
+        resolvedChannels,
+        exportedAt: transcript.meta.generatedAt,
+        poweredBy: props.poweredBy,
+        cdnBase: saveOpt ? "" : undefined,
+        mediaBase: saveOpt ? "" : undefined
+    });
+    let clientCode = await bundleClientToString();
+    if (assetManager) {
+        try {
+            await assetManager.downloadAssets(clientCode);
+            clientCode = assetManager.replaceUrls(clientCode);
+        }
+        catch (e) { }
+    }
+    let html = buildHtmlDocument(content, transcriptData, clientCode);
+    try {
+        const appCssPath = path_1.default.join(process.cwd(), "src", "web", "index.css");
+        const highlightCssPath = path_1.default.join(process.cwd(), "src", "web", "highlight-theme.css");
+        let appCss = await promises_1.default.readFile(appCssPath, "utf-8").catch(() => "");
+        let highlightCss = await promises_1.default.readFile(highlightCssPath, "utf-8").catch(() => "");
+        const highlightThemePath = path_1.default.join(process.cwd(), "node_modules", "highlight.js", "styles", "atom-one-dark.css");
+        const highlightTheme = await promises_1.default.readFile(highlightThemePath, "utf-8").catch(() => "");
+        if (highlightTheme) {
+            highlightCss = highlightCss.replace(/@import\s+['"]highlight\.js\/styles\/atom-one-dark\.css['"];?/g, highlightTheme);
+        }
+        else {
+            highlightCss = highlightCss.replace(/@import\s+['"]highlight\.js\/styles\/atom-one-dark\.css['"];?/g, "");
+        }
+        appCss = appCss.replace(/^@tailwind.*$/gm, "");
+        html = html.replace("[APP_CSS]", appCss.replace(/<\/style>/g, ""));
+        html = html.replace("[HIGHLIGHT_CSS]", highlightCss.replace(/<\/style>/g, ""));
+    }
+    catch (e) { }
+    if (assetManager) {
+        try {
+            await assetManager.downloadAssets(html);
+            html = assetManager.replaceUrls(html);
+        }
+        catch (e) { }
+    }
+    if (typeof filename === "string" && filename.length > 0) {
+        const finalFilename = filename;
+        const outputPath = path_1.default.join(process.cwd(), finalFilename);
+        await promises_1.default.writeFile(outputPath, html, "utf-8");
+        return outputPath;
+    }
+    return html;
+}
+async function bundleClientToString() {
+    const result = await esbuild_1.default.build({
+        entryPoints: [path_1.default.join(process.cwd(), "src", "web", "client.tsx")],
+        bundle: true,
+        minify: true,
+        platform: "browser",
+        format: "esm",
+        write: false,
+        jsx: "automatic"
+    });
+    return result.outputFiles[0].text;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+import { Collection, type Channel, type Message, type TextBasedChannel } from "discord.js";
+import { TranscriptCreateOptions } from "../types/general";
+export declare function createTranscript(channel: TextBasedChannel, options?: TranscriptCreateOptions): Promise<string>;
+export declare function createTranscriptRaw(channel: TextBasedChannel, options?: TranscriptCreateOptions): Promise<Message[]>;
+export declare function generateFromMessages(messages: Message[] | Collection<string, Message>, channel: Channel, options?: TranscriptCreateOptions): Promise<string>;

package/dist/src/index.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTranscript = createTranscript;
+exports.createTranscriptRaw = createTranscriptRaw;
+exports.generateFromMessages = generateFromMessages;
+const discord_js_1 = require("discord.js");
+const transformer_1 = require("./utils/transformer");
+const polls_1 = require("./utils/polls");
+const generateHtml_1 = require("./generateHtml");
+const djsVersion = discord_js_1.version.split(".")[0];
+if (djsVersion !== "14" && djsVersion !== "15") {
+    console.error(`Unsupported discord.js version: ${discord_js_1.version}. This library only supports v14 and v15 of discord.js.`);
+    process.exit(1);
+}
+async function createTranscript(channel, options = {}) {
+    if (!channel.isTextBased())
+        throw new TypeError("Provided channel must be text-based");
+    let channelMessages = [];
+    let lastMessageID;
+    const { limit } = options;
+    const resolveLimit = typeof limit === "undefined" ? Infinity : limit;
+    while (true) {
+        const fetchLimitOptions = { limit: 100, before: lastMessageID };
+        if (!lastMessageID)
+            delete fetchLimitOptions.before;
+        const messages = await channel.messages.fetch(fetchLimitOptions);
+        channelMessages.push(...messages.values());
+        lastMessageID = messages.lastKey();
+        if (messages.size < 100)
+            break;
+        if (channelMessages.length >= resolveLimit)
+            break;
+    }
+    if (resolveLimit < channelMessages.length)
+        channelMessages = channelMessages.slice(0, limit);
+    return generateFromMessages(channelMessages.reverse(), channel, options);
+}
+async function createTranscriptRaw(channel, options = {}) {
+    if (!channel.isTextBased())
+        throw new TypeError("Provided channel must be text-based");
+    let channelMessages = [];
+    let lastMessageID;
+    const { limit } = options;
+    const resolveLimit = typeof limit === "undefined" ? Infinity : limit;
+    while (true) {
+        const fetchLimitOptions = { limit: 100, before: lastMessageID };
+        if (!lastMessageID)
+            delete fetchLimitOptions.before;
+        const messages = await channel.messages.fetch(fetchLimitOptions);
+        channelMessages.push(...messages.values());
+        lastMessageID = messages.lastKey();
+        if (messages.size < 100)
+            break;
+        if (channelMessages.length >= resolveLimit)
+            break;
+    }
+    if (resolveLimit < channelMessages.length)
+        channelMessages = channelMessages.slice(0, limit);
+    return channelMessages.reverse();
+}
+async function generateFromMessages(messages, channel, options = {}) {
+    const messageArray = messages instanceof discord_js_1.Collection ? Array.from(messages.values()) : messages;
+    const batchSize = 25;
+    const messagesSerialized = [];
+    const resolvedAuthorsMap = new Map();
+    const resolvedRolesMap = new Map();
+    const resolvedChannelsMap = new Map();
+    const transcriptGuildId = channel.guild?.id ?? null;
+    const roleMentionRegex = /<@&(\d+)>/g;
+    for (let i = 0; i < messageArray.length; i += batchSize) {
+        const batch = messageArray.slice(i, i + batchSize);
+        const serialized = await Promise.all(batch.map((m) => (0, transformer_1.messageToSerializable)(m)));
+        for (let j = 0; j < serialized.length; j++) {
+            const result = serialized[j];
+            if (!result)
+                continue;
+            if (result.author) {
+                resolvedAuthorsMap.set(result.author.id, result.author);
+            }
+            if (result.message.poll) {
+                await (0, polls_1.enrichPollVoters)(batch[j], result.message.poll);
+            }
+            messagesSerialized.push(result.message);
+        }
+        for (const message of batch) {
+            let allContent = message.content ?? "";
+            if (message.embeds) {
+                const embedArray = Array.isArray(message.embeds)
+                    ? message.embeds
+                    : typeof message.embeds.values === "function"
+                        ? Array.from(message.embeds.values())
+                        : [];
+                for (const embed of embedArray) {
+                    if (embed.title)
+                        allContent += " " + embed.title;
+                    if (embed.description)
+                        allContent += " " + embed.description;
+                    if (embed.fields) {
+                        for (const field of embed.fields) {
+                            if (field.name)
+                                allContent += " " + field.name;
+                            if (field.value)
+                                allContent += " " + field.value;
+                        }
+                    }
+                    if (embed.footer?.text)
+                        allContent += " " + embed.footer.text;
+                }
+            }
+            let match;
+            roleMentionRegex.lastIndex = 0;
+            while ((match = roleMentionRegex.exec(allContent)) !== null) {
+                const roleId = match[1];
+                if (resolvedRolesMap.has(roleId))
+                    continue;
+                try {
+                    if (message.guild) {
+                        const role = await message.guild.roles.fetch(roleId).catch(() => null);
+                        if (role) {
+                            resolvedRolesMap.set(roleId, {
+                                name: role.name,
+                                color: role.hexColor
+                            });
+                        }
+                    }
+                }
+                catch { }
+            }
+            if (message.mentions?.roles) {
+                for (const role of message.mentions.roles.values?.() ?? []) {
+                    if (!resolvedRolesMap.has(role.id)) {
+                        resolvedRolesMap.set(role.id, {
+                            name: role.name,
+                            color: role.hexColor
+                        });
+                    }
+                }
+            }
+            if (message.mentions?.channels) {
+                for (const mentionedChannel of message.mentions.channels.values?.() ?? []) {
+                    if (mentionedChannel && mentionedChannel.id && !resolvedChannelsMap.has(mentionedChannel.id)) {
+                        const mentionGuildId = mentionedChannel.guildId ?? mentionedChannel.guild?.id ?? message.guild?.id ?? null;
+                        if (transcriptGuildId && mentionGuildId && mentionGuildId !== transcriptGuildId) {
+                            continue;
+                        }
+                        resolvedChannelsMap.set(mentionedChannel.id, {
+                            name: mentionedChannel.name ?? null,
+                            guildId: mentionGuildId
+                        });
+                    }
+                }
+            }
+        }
+    }
+    const resolvedUsersObj = {};
+    for (const [userId, authorData] of resolvedAuthorsMap.entries()) {
+        const { id: _discard, ...authorWithoutId } = authorData ?? {};
+        resolvedUsersObj[userId] = authorWithoutId;
+    }
+    const resolvedRolesObj = {};
+    for (const [roleId, roleData] of resolvedRolesMap.entries()) {
+        resolvedRolesObj[roleId] = roleData;
+    }
+    const resolvedChannelsObj = {};
+    for (const [channelId, channelData] of resolvedChannelsMap.entries()) {
+        resolvedChannelsObj[channelId] = channelData;
+    }
+    if (options?.ignore?.attachments) {
+        const ignoreImgs = !!options.ignore.attachments.images;
+        const ignoreVids = !!options.ignore.attachments.videos;
+        const ignoreAudio = !!options.ignore.attachments.audio;
+        const ignoreFiles = !!options.ignore.attachments.files;
+        for (const m of messagesSerialized) {
+            if (!m.attachments || !Array.isArray(m.attachments))
+                continue;
+            const filtered = m.attachments.filter((a) => {
+                const url = typeof a === "string" ? a : (a && (a.url || "")) || "";
+                const isImage = /\.(png|jpe?g|gif|webp|svg|bmp|avif)(\?|$)/i.test(url);
+                const isVideo = /\.(mp4|mov|webm|avi|mkv)(\?|$)/i.test(url);
+                const isAudio = /\.(mp3|wav|ogg|m4a|flac|aac|weba)(\?|$)/i.test(url);
+                if (ignoreImgs && isImage)
+                    return false;
+                if (ignoreVids && isVideo)
+                    return false;
+                if (ignoreAudio && isAudio)
+                    return false;
+                if (ignoreFiles && !isImage && !isVideo && !isAudio)
+                    return false;
+                return true;
+            });
+            m.attachments = filtered;
+        }
+    }
+    function messageHasVisibleContent(m) {
+        if (m.content && String(m.content).trim().length > 0)
+            return true;
+        if (m.attachments && Array.isArray(m.attachments) && m.attachments.length > 0)
+            return true;
+        if (m.stickers && Array.isArray(m.stickers) && m.stickers.length > 0)
+            return true;
+        if (m.poll)
+            return true;
+        if (m.buttons && Array.isArray(m.buttons) && m.buttons.length > 0)
+            return true;
+        if (m.selects && Array.isArray(m.selects) && m.selects.length > 0)
+            return true;
+        if (m.forwardedMessage) {
+            if (m.forwardedMessage.content && String(m.forwardedMessage.content).trim().length > 0)
+                return true;
+            if (m.forwardedMessage.attachments && m.forwardedMessage.attachments.length > 0)
+                return true;
+        }
+        if (m.embeds && Array.isArray(m.embeds)) {
+            for (const e of m.embeds) {
+                if (!e)
+                    continue;
+                if (e.title && String(e.title).trim())
+                    return true;
+                if (e.description && String(e.description).trim())
+                    return true;
+                if (e.footer && e.footer.text && String(e.footer.text).trim())
+                    return true;
+                if (e.author && (e.author.name || e.author.url))
+                    return true;
+                if (e.image && e.image.url)
+                    return true;
+                if (e.thumbnail && e.thumbnail.url)
+                    return true;
+                if (e.fields && Array.isArray(e.fields) && e.fields.some((f) => (f.name && String(f.name).trim()) || (f.value && String(f.value).trim())))
+                    return true;
+            }
+        }
+        return false;
+    }
+    const filteredMessages = messagesSerialized.filter((m) => messageHasVisibleContent(m));
+    messagesSerialized.length = 0;
+    messagesSerialized.push(...filteredMessages);
+    const transcript = {
+        meta: {
+            channelId: channel.id ?? "unknown",
+            channelName: channel.name ?? null,
+            guildId: channel.guild?.id ?? null,
+            generatedAt: new Date().toISOString(),
+            messageCount: messagesSerialized.length
+        },
+        messages: messagesSerialized,
+        resolvedUsers: resolvedUsersObj,
+        resolvedRoles: resolvedRolesObj,
+        resolvedChannels: resolvedChannelsObj
+    };
+    return await (0, generateHtml_1.generateHtml)(transcript, options);
+}

package/dist/src/transcript.d.ts

@@ -0,0 +1,12 @@
+import { Collection, type Channel, type Message, type TextBasedChannel, type User } from "discord.js";
+import { TranscriptCreateOptions } from "../types/general";
+import type { SerializableMessage } from "../types/exportableTranscript";
+type GuildTag = {
+    name?: string | null;
+    iconUrl?: string | null;
+};
+export declare function resolveGuildTagForUser(user: User): Promise<GuildTag>;
+export declare function mapMessageToSerializable(m: Message): Promise<SerializableMessage>;
+export declare function createTranscript(channel: TextBasedChannel, options?: TranscriptCreateOptions): Promise<string>;
+export declare function generateFromMessages(messages: Message[] | Collection<string, Message>, channel: Channel, options?: TranscriptCreateOptions): Promise<string>;
+export {};