discord-html-transcripts

Both createTranscript and generateFromMessages accept an optional configuration object.

Available Options:

• limit: Max amount of messages to fetch. Use -1 to fetch recursively.
• returnType: 'attachment' (default), 'buffer', or 'string'. Use the ExportReturnType enum for type safety.
• filename: Name of the file (only valid if returnType is 'attachment').
• saveImages: If true, downloads all images and embeds them in the HTML. This allows viewing images even after they are deleted from Discord, but increases file size.
• footerText: Custom text for the footer. Use {number} for the message count and {s} for pluralization.
• poweredBy: Boolean to include/exclude the "Powered by discord-html-transcripts" footer.
• hydrate: Boolean to determine if the HTML should be hydrated server-side.
• filter: A function (message) => boolean to include or exclude specific messages (e.g., (message) => !message.author.bot).
• callbacks: An object to provide custom resolvers for Discord entities:
  • resolveChannel: (channelId: string) => Awaitable<Channel | null>
  • resolveUser: (userId: string) => Awaitable<User | null>
  • resolveRole: (roleId: string) => Awaitable<Role | null>
  • resolveImageSrc: (attachment: APIAttachment, message: APIMessage) => Awaitable<string | null | undefined>

const attachment = await discordTranscripts.createTranscript(channel, {
    limit: -1,
    returnType: 'attachment',
    filename: 'transcript.html',
    saveImages: false,
    footerText: "Exported {number} message{s}",
    callbacks: {
      resolveChannel: (channelId) => /* logic */,
      resolveUser: (userId) => /* logic */,
      resolveRole: (roleId) => /* logic */,
      resolveImageSrc: (attachment, message) => /* logic */
    },
    poweredBy: true,
    hydrate: true,
    filter: (message) => !message.author.bot
});

Use generateFromMessages when you want to provide your own specific set of messages for the transcript instead of having the library fetch them automatically from a channel. This allows for finer control over exactly which messages are included in the output.

Parameters:

• messages: An array of discord.js Message objects or a Collection<string, Message>.
• channel: A TextBasedChannel (used to extract metadata like guild name, icon, and channel name).
• options: A GenerateFromMessagesOptions object to configure the output.

By default, the function returns an AttachmentBuilder which can be sent directly to a Discord channel using channel.send({ files: [attachment] }).

import * as discordTranscripts from "discord-html-transcripts";
import { Collection, Message } from "discord.js";

const messages = new Collection<string, Message>();
const channel = /* your channel object */;

// Fill the messages collection with the desired messages

const transcript = await discordTranscripts.generateFromMessages(
    messages, 
    channel, 
    { /* options */ }
);

// Send the resulting attachment to the channel
await channel.send({
    files: [transcript]
});

The createTranscript function fetches messages from a specified TextBasedChannel and generates an HTML transcript. By default, it returns an AttachmentBuilder object, which can be passed directly to message.reply or other discord.js methods in the files array.

Note that createTranscript is an asynchronous function and must be awaited.

const discordTranscripts = require("discord-html-transcripts");

client.on('messageCreate', async (message) => {
    if (message.content === "!transcript") {
        // Fetches messages and returns an AttachmentBuilder
        const transcript = await discordTranscripts.createTranscript(
            message.channel,
            {
                saveImages: true,
                footerText: "Saved {number} message{s}"
            }
        );

        // Send the transcript directly to the channel
        await message.reply({
            content: "Here's your transcript!",
            files: [transcript]
        });
    }
});

The createTranscript function accepts two arguments:

1. channel: TextBasedChannel: The channel to fetch messages from. This can be a TextChannel, NewsChannel, ThreadChannel, or VoiceChannel (as defined in discord.js).
2. options: CreateTranscriptOptions: An optional configuration object.

Available Options

// Signature
createTranscript(channel, (options = {}));

The options object allows you to customize the transcript generation process.

Return Type

options.returnType: Determines the format of the returned data.

• 'buffer': Returns the HTML data as a Buffer.
• 'string': Returns the HTML data as a string.
• 'attachment': Returns an AttachmentBuilder (Default).

File and Content Customization

• options.filename: The name of the output file (only used if returnType is 'attachment'). Default: transcript-{channel id}.html.
• options.saveImages: A boolean. If true, the library downloads all image attachments and embeds them directly in the HTML. This prevents broken images if the original Discord attachments are deleted, but significantly increases file size and may hit Discord's upload limits.
• options.footerText: Custom text for the transcript footer. Supports placeholders:
  • {number}: Total number of messages exported.
  • {s}: Adds an 's' if the number is > 0 (for pluralization).
• options.poweredBy: A boolean to show or hide the "Powered by discord-html-transcripts" footer (Default: true).

Custom Resolvers (Callbacks)

If your bot uses specific caching or custom fetching logic, you can provide custom callback functions via options.callbacks to resolve Discord entities mentioned in the transcript:

• resolveChannel: (channelId: string) => Awaitable<Channel | null>
• resolveUser: (userId: string) => Awaitable<User | null>
• resolveRole: (roleId: string) => Awaitable<Role | null>

const attachment = await discordTranscripts.generateFromMessages(
    messages,
    channel,
    {
        returnType: 'attachment', // 'buffer' | 'string' | 'attachment'
        filename: 'transcript.html',
        saveImages: false,
        footerText: "Exported {number} message{s}",
        poweredBy: true,
        callbacks: {
            resolveChannel: async (channelId) => await channel.client.channels.fetch(channelId),
            resolveUser: async (userId) => await channel.client.users.fetch(userId),
            resolveRole: async (roleId) => await channel.guild.roles.fetch(roleId)
        }
    }
);