discord-message-transcript 1.2.0-dev.1.2.0.12.0 → 1.2.0

package/README.md

@@ -50,6 +50,7 @@ This project provides two packages:
 - Single-file HTML output
 - Lightweight JSON format
 - Optional image embedding
+- Optional CDN Upload (Can be custom)
 - Markdown + syntax highlighting
 - No tracking or telemetry
 

package/dist/core/cdnResolver.d.ts

@@ -1,2 +1,5 @@
 import { CDNOptions } from "../types/types.js";
-export declare function cdnResolver(url: string, cdnOptions: CDNOptions<unknown>): Promise<string>;
+import { TranscriptOptionsBase } from "discord-message-transcript-base";
+export declare function cdnResolver(url: string, options: TranscriptOptionsBase, cdnOptions: CDNOptions): Promise<string>;
+export declare function uploadCareResolver(url: string, publicKey: string, cdnDomain: string): Promise<string>;
+export declare function cloudinaryResolver(url: string, fileName: string, cloudName: string, apiKey: string, apiSecret: string): Promise<string>;

package/dist/core/cdnResolver.js

@@ -1,56 +1,197 @@
 import https from 'https';
 import http from 'http';
 import { CustomWarn } from "discord-message-transcript-base";
-export async function cdnResolver(url, cdnOptions) {
-    return new Promise((resolve, reject) => {
-        const client = url.startsWith('https') ? https : http;
-        const request = client.get(url, { headers: { "User-Agent": "discord-message-transcript" } }, async (response) => {
-            if (response.statusCode !== 200) {
+import crypto from 'crypto';
+import { getCDNLimiter } from "./limiter.js";
+export async function cdnResolver(url, options, cdnOptions) {
+    const limit = getCDNLimiter();
+    return limit(async () => {
+        return new Promise((resolve, reject) => {
+            const client = url.startsWith('https') ? https : http;
+            const request = client.request(url, {
+                method: 'HEAD',
+                headers: { "User-Agent": "discord-message-transcript" }
+            }, async (response) => {
+                if (response.statusCode !== 200) {
+                    response.destroy();
+                    CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Failed to fetch attachment with status code: ${response.statusCode} from ${url}.`);
+                    return resolve(url);
+                }
+                const contentType = response.headers["content-type"];
+                const splitContentType = contentType ? contentType?.split('/') : [];
+                if (!contentType || splitContentType.length != 2 || splitContentType[0].length == 0 || splitContentType[1].length == 0) {
+                    response.destroy();
+                    CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Failed to receive a valid content-type from ${url}.`);
+                    return resolve(url);
+                }
                 response.destroy();
-                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.\nFailed to fetch attachment with status code: ${response.statusCode} from ${url}.`);
+                const isImage = contentType.startsWith('image/') && contentType !== 'image/gif';
+                const isAudio = contentType.startsWith('audio/');
+                const isVideo = contentType.startsWith('video/') || contentType === 'image/gif';
+                if ((cdnOptions.includeImage && isImage) ||
+                    (cdnOptions.includeAudio && isAudio) ||
+                    (cdnOptions.includeVideo && isVideo) ||
+                    (cdnOptions.includeOthers && !isAudio && !isImage && !isVideo)) {
+                    return resolve(await cdnRedirectType(url, options, contentType, cdnOptions));
+                }
                 return resolve(url);
-            }
-            const contentType = response.headers["content-type"];
-            const splitContentType = contentType ? contentType?.split('/') : [];
-            if (!contentType || splitContentType.length != 2 || splitContentType[0].length == 0 || splitContentType[1].length == 0) {
-                response.destroy();
-                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.\nFailed to receive a valid content-type from ${url}.`);
+            });
+            request.on('error', (err) => {
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Error: ${err.message}`);
                 return resolve(url);
-            }
-            response.destroy();
-            const isImage = contentType.startsWith('image/') && contentType !== 'image/gif';
-            const isAudio = contentType.startsWith('audio/');
-            const isVideo = contentType.startsWith('video/') || contentType === 'image/gif';
-            if ((cdnOptions.includeImage && isImage) ||
-                (cdnOptions.includeAudio && isAudio) ||
-                (cdnOptions.includeVideo && isVideo) ||
-                (cdnOptions.includeOthers && !isAudio && !isImage && !isVideo)) {
-                return resolve(await cdnRedirectType(url, contentType, cdnOptions));
-            }
-            return resolve(url);
+            });
+            request.setTimeout(15000, () => {
+                request.destroy();
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Request timeout for ${url}.`);
+                resolve(url);
+            });
+            request.end();
         });
-        request.on('error', (err) => {
-            CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.\nError message: ${err.message}`);
-            return resolve(url);
-        });
-        request.setTimeout(15000, () => {
-            request.destroy();
-            CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.\nRequest timeout for ${url}. Using original URL.`);
-            resolve(url);
-        });
-        request.end();
     });
 }
-async function cdnRedirectType(url, contentType, cdnOptions) {
-    switch (cdnOptions.type) {
+async function cdnRedirectType(url, options, contentType, cdnOptions) {
+    switch (cdnOptions.provider) {
         case "CUSTOM": {
-            return await cdnOptions.customCdnResolver(url, contentType, cdnOptions.other);
+            try {
+                return await cdnOptions.resolver(url, contentType, cdnOptions.customData);
+            }
+            catch (error) {
+                CustomWarn(`Custom CDN resolver threw an error. Falling back to original URL.
+This is most likely an issue in the custom CDN implementation provided by the user.
+URL: ${url}
+Error: ${error?.message ?? error}`);
+                return url;
+            }
+        }
+        case "CLOUDINARY": {
+            return await cloudinaryResolver(url, options.fileName, cdnOptions.cloudName, cdnOptions.apiKey, cdnOptions.apiSecret);
+            ;
         }
-        case "CLOUDFLARE_R2": {
-            return await cdnCloudflareR2();
+        case "UPLOADCARE": {
+            return await uploadCareResolver(url, cdnOptions.publicKey, cdnOptions.cdnDomain);
         }
     }
 }
-async function cdnCloudflareR2() {
-    return ''; // TODO: Implement cloudflareR2 cdn
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+export async function uploadCareResolver(url, publicKey, cdnDomain) {
+    try {
+        const form = new FormData();
+        form.append("pub_key", publicKey);
+        form.append("source_url", url);
+        form.append("store", "1");
+        form.append("check_URL_duplicates", "1");
+        form.append("save_URL_duplicates", "1");
+        const res = await fetch("https://upload.uploadcare.com/from_url/", {
+            method: "POST",
+            body: form,
+            headers: {
+                "User-Agent": "discord-message-transcript"
+            }
+        });
+        if (!res.ok) {
+            switch (res.status) {
+                case 400:
+                    throw new Error(`Uploadcare initial request failed with status code ${res.status} - Request failed input parameters validation.`);
+                case 403:
+                    throw new Error(`Uploadcare initial request failed with status code ${res.status} - Request was not allowed.`);
+                case 429:
+                    throw new Error(`Uploadcare initial request failed with status code ${res.status} - Request was throttled.`);
+                default:
+                    throw new Error(`Uploadcare initial request failed with status code ${res.status}`);
+            }
+        }
+        const json = await res.json();
+        if (json.uuid) {
+            return `https://${cdnDomain}/${json.uuid}/`;
+        }
+        let delay = 200;
+        let maxDelay = 2000;
+        if (json.token) {
+            for (let i = 0; i < 10; i++) {
+                await sleep(delay);
+                delay = Math.min(delay * 2, maxDelay);
+                const resToken = await fetch(`https://upload.uploadcare.com/from_url/status/?token=${json.token}&pub_key=${publicKey}`, { headers: { "User-Agent": "discord-message-transcript" } });
+                if (!resToken.ok)
+                    throw new Error(`Uploadcare status failed with status code ${resToken.status}`);
+                const jsonToken = await resToken.json();
+                if (jsonToken.status === "success" && jsonToken.file_id) {
+                    return `https://${cdnDomain}/${jsonToken.file_id}/`;
+                }
+                if (jsonToken.status === "error") {
+                    throw new Error(jsonToken.error || "Uploadcare failed");
+                }
+            }
+            throw new Error("Uploadcare polling timeout");
+        }
+        return url;
+    }
+    catch (error) {
+        CustomWarn(`Uploadcare CDN upload failed. Using original URL as fallback.
+Check Uploadcare public key, CDN domain, project settings, rate limits, and network access.
+URL: ${url}
+Error: ${error?.message ?? error}`);
+        return url;
+    }
+}
+export async function cloudinaryResolver(url, fileName, cloudName, apiKey, apiSecret) {
+    try {
+        const paramsToSign = {
+            folder: `discord-message-transcript/${fileName}`,
+            timestamp: Math.floor(Date.now() / 1000).toString(),
+            unique_filename: "true",
+            use_filename: "true",
+        };
+        const stringToSign = Object.keys(paramsToSign).sort().map(k => `${k}=${paramsToSign[k]}`).join("&");
+        // signature SHA1
+        const signature = crypto
+            .createHash("sha1")
+            .update(stringToSign + apiSecret)
+            .digest("hex");
+        const form = new FormData();
+        form.append("folder", paramsToSign.folder);
+        form.append("file", url);
+        form.append("api_key", apiKey);
+        form.append("timestamp", paramsToSign.timestamp);
+        form.append("signature", signature);
+        form.append("use_filename", paramsToSign.use_filename);
+        form.append("unique_filename", paramsToSign.unique_filename);
+        const res = await fetch(`https://api.cloudinary.com/v1_1/${cloudName}/auto/upload`, {
+            method: "POST",
+            body: form,
+            headers: {
+                "User-Agent": "discord-message-transcript"
+            }
+        });
+        if (!res.ok) {
+            switch (res.status) {
+                case 400:
+                    throw new Error(`Cloudinary upload failed with status code ${res.status} - Bad request / invalid params.`);
+                case 403:
+                    throw new Error(`Cloudinary upload failed with status code ${res.status} - Invalid credentials or unauthorized.`);
+                case 429:
+                    throw new Error(`Cloudinary upload failed with status code ${res.status} - Rate limited.`);
+                default:
+                    throw new Error(`Cloudinary upload failed with status code ${res.status}.`);
+            }
+        }
+        const json = await res.json();
+        if (!json.secure_url) {
+            throw new Error("Cloudinary response missing secure_url");
+        }
+        return json.secure_url;
+    }
+    catch (error) {
+        CustomWarn(`Failed to upload asset to Cloudinary CDN. Using original URL as fallback.
+Check Cloudinary configuration (cloud name, API key, API secret) and network access.
+URL: ${url}
+Error: ${error?.message ?? error}`);
+        return url;
+    }
 }
+// Note: for debug use ${JSON.stringify(await res.json())} to understand the error

package/dist/core/componentToJson.d.ts

@@ -1,4 +1,4 @@
 import { TopLevelComponent } from "discord.js";
-import { JsonTopLevelComponent, TranscriptOptionsBase } from "discord-message-transcript-base";
-import { CDNOptions } from "../types/types.js";
-export declare function componentsToJson(components: TopLevelComponent[], options: TranscriptOptionsBase, cdnOptions: CDNOptions<unknown> | null): Promise<JsonTopLevelComponent[]>;
+import { JsonTopLevelComponent, JsonComponentInContainer, TranscriptOptionsBase } from "discord-message-transcript-base";
+export declare function componentsToJson(components: TopLevelComponent[], options: TranscriptOptionsBase): Promise<JsonTopLevelComponent[]>;
+export declare function isJsonComponentInContainer(component: JsonTopLevelComponent): component is JsonComponentInContainer;

package/dist/core/componentToJson.js

@@ -1,8 +1,7 @@
 import { ComponentType } from "discord.js";
 import { mapButtonStyle, mapSelectorType, mapSeparatorSpacing } from "./mappers.js";
 import { JsonComponentType } from "discord-message-transcript-base";
-import { urlResolver } from "./urlResolver.js";
-export async function componentsToJson(components, options, cdnOptions) {
+export async function componentsToJson(components, options) {
     const processedComponents = await Promise.all(components.filter(component => !(!options.includeV2Components && component.type != ComponentType.ActionRow))
         .map(async (component) => {
         switch (component.type) {
@@ -54,7 +53,7 @@ export async function componentsToJson(components, options, cdnOptions) {
             }
             case ComponentType.Container: {
                 const newOptions = { ...options, includeComponents: true, includeButtons: true };
-                const componentsJson = await componentsToJson(component.components, newOptions, cdnOptions);
+                const componentsJson = await componentsToJson(component.components, newOptions);
                 return {
                     type: JsonComponentType.Container,
                     components: componentsJson.filter(isJsonComponentInContainer), // Input components that are container-safe must always produce container-safe output.
@@ -67,17 +66,17 @@ export async function componentsToJson(components, options, cdnOptions) {
                     type: JsonComponentType.File,
                     fileName: component.data.name ?? null,
                     size: component.data.size ?? 0,
-                    url: await urlResolver(component.file.url, options, cdnOptions),
+                    url: component.file.url,
                     spoiler: component.spoiler,
                 };
             }
             case ComponentType.MediaGallery: {
-                const mediaItems = await Promise.all(component.items.map(async (item) => {
+                const mediaItems = component.items.map(item => {
                     return {
-                        media: { url: await urlResolver(item.media.url, options, cdnOptions) },
+                        media: { url: item.media.url },
                         spoiler: item.spoiler,
                     };
-                }));
+                });
                 return {
                     type: JsonComponentType.MediaGallery,
                     items: mediaItems,
@@ -99,7 +98,7 @@ export async function componentsToJson(components, options, cdnOptions) {
                     accessoryJson = {
                         type: JsonComponentType.Thumbnail,
                         media: {
-                            url: await urlResolver(component.accessory.media.url, options, cdnOptions),
+                            url: component.accessory.media.url,
                         },
                         spoiler: component.accessory.spoiler,
                     };
@@ -135,7 +134,7 @@ export async function componentsToJson(components, options, cdnOptions) {
     }));
     return processedComponents.filter(c => c != null);
 }
-function isJsonComponentInContainer(component) {
+export function isJsonComponentInContainer(component) {
     return (component.type == JsonComponentType.ActionRow ||
         component.type == JsonComponentType.File ||
         component.type == JsonComponentType.MediaGallery ||

package/dist/core/fetchMessages.d.ts

@@ -1,7 +1,19 @@
 import { TextBasedChannel } from "discord.js";
 import { JsonAuthor, JsonMessage, TranscriptOptionsBase } from "discord-message-transcript-base";
-import { CDNOptions, MapMentions } from "../types/types.js";
-export declare function fetchMessages(channel: TextBasedChannel, options: TranscriptOptionsBase, cdnOptions: CDNOptions<unknown> | null, authors: Map<string, JsonAuthor>, mentions: MapMentions, after?: string): Promise<{
+import { MapMentions } from "../types/types.js";
+export declare function fetchMessages(ctx: FetchMessagesContext): Promise<{
     messages: JsonMessage[];
     end: boolean;
+    newLastMessageId: string | undefined;
 }>;
+export type FetchMessagesContext = {
+    channel: TextBasedChannel;
+    options: TranscriptOptionsBase;
+    transcriptState: TranscriptState;
+    lastMessageId: string | undefined;
+};
+type TranscriptState = {
+    authors: Map<string, JsonAuthor>;
+    mentions: MapMentions;
+};
+export {};

package/dist/core/fetchMessages.js

@@ -1,45 +1,41 @@
 import { EmbedType } from "discord.js";
 import { componentsToJson } from "./componentToJson.js";
-import { urlResolver } from "./urlResolver.js";
 import { getMentions } from "./getMentions.js";
-export async function fetchMessages(channel, options, cdnOptions, authors, mentions, after) {
-    const originalMessages = await channel.messages.fetch({ limit: 100, cache: false, after: after });
+export async function fetchMessages(ctx) {
+    const { channel, options, transcriptState, lastMessageId } = ctx;
+    const { authors, mentions } = transcriptState;
+    const originalMessages = await channel.messages.fetch({ limit: 100, cache: false, before: lastMessageId });
     const rawMessages = await Promise.all(originalMessages.map(async (message) => {
-        const attachments = await Promise.all(message.attachments.map(async (attachment) => {
+        const attachments = message.attachments.map(attachment => {
             return {
                 contentType: attachment.contentType,
                 name: attachment.name,
                 size: attachment.size,
                 spoiler: attachment.spoiler,
-                url: await urlResolver(attachment.url, options, cdnOptions),
+                url: attachment.url,
             };
-        }));
+        });
         // This only works because embeds with the type poll_result that are send when a poll end are marked as a message send by the system  
-        const embeds = message.system && message.embeds.length == 1 && message.embeds[0].data.type == EmbedType.PollResult && !options.includePolls ? []
-            : await Promise.all(message.embeds.map(async (embed) => {
-                const [authorIcon, thumbnailUrl, imageUrl, footerIcon] = await Promise.all([
-                    embed.author?.iconURL ? urlResolver(embed.author.iconURL, options, cdnOptions) : Promise.resolve(null),
-                    embed.thumbnail?.url ? urlResolver(embed.thumbnail.url, options, cdnOptions) : Promise.resolve(null),
-                    embed.image?.url ? urlResolver(embed.image.url, options, cdnOptions) : Promise.resolve(null),
-                    embed.footer?.iconURL ? urlResolver(embed.footer.iconURL, options, cdnOptions) : Promise.resolve(null),
-                ]);
+        const embeds = message.system && message.embeds.length == 1 && message.embeds[0].data.type == EmbedType.PollResult && !options.includePolls
+            ? []
+            : message.embeds.map(embed => {
                 return {
-                    author: embed.author ? { name: embed.author.name, url: embed.author.url ?? null, iconURL: authorIcon } : null,
+                    author: embed.author ? { name: embed.author.name, url: embed.author.url ?? null, iconURL: embed.author?.iconURL ?? null } : null,
                     description: embed.description ?? null,
                     fields: embed.fields.map(field => ({ inline: field.inline ?? false, name: field.name, value: field.value })),
-                    footer: embed.footer ? { iconURL: footerIcon, text: embed.footer.text } : null,
+                    footer: embed.footer ? { iconURL: embed.footer?.iconURL ?? null, text: embed.footer.text } : null,
                     hexColor: embed.hexColor ?? null,
-                    image: imageUrl ? { url: imageUrl } : null,
-                    thumbnail: thumbnailUrl ? { url: thumbnailUrl } : null,
+                    image: embed.image?.url ? { url: embed.image.url } : null,
+                    thumbnail: embed.thumbnail?.url ? { url: embed.thumbnail.url } : null,
                     timestamp: embed.timestamp,
                     title: embed.title,
                     type: embed.data.type ?? "rich",
                     url: embed.url,
                 };
-            }));
+            });
         if (!authors.has(message.author.id)) {
             authors.set(message.author.id, {
-                avatarURL: await urlResolver(message.author.displayAvatarURL(), options, cdnOptions),
+                avatarURL: message.author.displayAvatarURL(),
                 bot: message.author.bot,
                 displayName: message.author.displayName,
                 guildTag: message.author.primaryGuild?.tag ?? null,
@@ -51,7 +47,7 @@ export async function fetchMessages(channel, options, cdnOptions, authors, menti
                 system: message.author.system,
             });
         }
-        const components = await componentsToJson(message.components, options, cdnOptions);
+        const components = await componentsToJson(message.components, options);
         await getMentions(message, mentions);
         return {
             attachments: options.includeAttachments ? attachments : [],
@@ -89,9 +85,10 @@ export async function fetchMessages(channel, options, cdnOptions, authors, menti
             system: message.system,
         };
     }));
+    const newLastMessageId = originalMessages.last()?.id;
     const messages = rawMessages.filter(m => !(!options.includeEmpty && m.attachments.length == 0 && m.components.length == 0 && m.content == "" && m.embeds.length == 0 && !m.poll));
     const end = originalMessages.size !== 100;
-    return { messages, end };
+    return { messages, end, newLastMessageId };
 }
 function formatTimeLeftPoll(timestamp) {
     const now = new Date();

package/dist/core/imageToBase64.js

@@ -1,43 +1,53 @@
 import https from 'https';
 import http from 'http';
 import { CustomWarn } from 'discord-message-transcript-base';
+import { getBase64Limiter } from './limiter.js';
 export async function imageToBase64(url) {
-    return new Promise((resolve, reject) => {
-        const client = url.startsWith('https') ? https : http;
-        const request = client.get(url, { headers: { "User-Agent": "discord-message-transcript" } }, (response) => {
-            if (response.statusCode !== 200) {
-                response.destroy();
-                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.\nFailed to fetch image with status code: ${response.statusCode} from ${url}.`);
-                return resolve(url);
-            }
-            const contentType = response.headers['content-type'];
-            if (!contentType || !contentType.startsWith('image/') || contentType === 'image/gif') {
-                response.destroy();
-                return resolve(url);
-            }
-            const chunks = [];
-            response.on('data', (chunk) => {
-                chunks.push(chunk);
+    const limit = getBase64Limiter();
+    return limit(async () => {
+        return new Promise((resolve, reject) => {
+            const client = url.startsWith('https') ? https : http;
+            const request = client.get(url, { headers: { "User-Agent": "discord-message-transcript" } }, (response) => {
+                if (response.statusCode !== 200) {
+                    response.destroy();
+                    CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
+Failed to fetch image with status code: ${response.statusCode} from ${url}.`);
+                    return resolve(url);
+                }
+                const contentType = response.headers['content-type'];
+                if (!contentType || !contentType.startsWith('image/') || contentType === 'image/gif') {
+                    response.destroy();
+                    return resolve(url);
+                }
+                const chunks = [];
+                response.on('data', (chunk) => {
+                    chunks.push(chunk);
+                });
+                response.on('end', () => {
+                    const buffer = Buffer.concat(chunks);
+                    const base64 = buffer.toString('base64');
+                    resolve(`data:${contentType};base64,${base64}`);
+                });
+                response.on('error', (err) => {
+                    CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
+Stream error while fetching from ${url}.
+Error: ${err.message}`);
+                    resolve(url);
+                });
             });
-            response.on('end', () => {
-                const buffer = Buffer.concat(chunks);
-                const base64 = buffer.toString('base64');
-                resolve(`data:${contentType};base64,${base64}`);
+            request.on('error', (err) => {
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
+Error fetching image from ${url}
+Error: ${err.message}`);
+                return resolve(url);
             });
-            response.on('error', (err) => {
-                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.\nStream error while fetching from ${url}.\nError message: ${err.message}`);
+            request.setTimeout(15000, () => {
+                request.destroy();
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
+Request timeout for ${url}.`);
                 resolve(url);
             });
+            request.end();
         });
-        request.on('error', (err) => {
-            CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.\nError fetching image from ${url}\nError message: ${err.message}`);
-            return resolve(url);
-        });
-        request.setTimeout(15000, () => {
-            request.destroy();
-            CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.\nRequest timeout for ${url}. Using original URL.`);
-            resolve(url);
-        });
-        request.end();
     });
 }

package/dist/core/limiter.d.ts

@@ -0,0 +1,5 @@
+export declare function getCDNLimiter(): <T>(fn: () => Promise<T>) => Promise<T>;
+export declare function getBase64Limiter(): <T>(fn: () => Promise<T>) => Promise<T>;
+export declare function setCDNConcurrency(n: number): void;
+export declare function setBase64Concurrency(n: number): void;
+export declare function createLimiter(concurrency: number): <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/core/limiter.js

@@ -0,0 +1,47 @@
+const globalLimiters = {
+    cdn: createLimiter(12),
+    base64: createLimiter(6)
+};
+export function getCDNLimiter() {
+    return globalLimiters.cdn;
+}
+export function getBase64Limiter() {
+    return globalLimiters.base64;
+}
+export function setCDNConcurrency(n) {
+    globalLimiters.cdn = createLimiter(n);
+}
+export function setBase64Concurrency(n) {
+    globalLimiters.base64 = createLimiter(n);
+}
+export function createLimiter(concurrency) {
+    if (concurrency <= 0) {
+        throw new Error("Limiter must be greater than 0");
+    }
+    let active = 0;
+    const queue = [];
+    const next = () => {
+        active = Math.max(0, active - 1);
+        if (queue.length > 0 && active < concurrency) {
+            const run = queue.shift();
+            run?.();
+        }
+    };
+    return function limit(fn) {
+        return new Promise((resolve, reject) => {
+            const run = () => {
+                active++;
+                Promise.resolve()
+                    .then(fn)
+                    .then(resolve, reject)
+                    .finally(next);
+            };
+            if (active < concurrency) {
+                run();
+            }
+            else {
+                queue.push(run);
+            }
+        });
+    };
+}

package/dist/core/urlResolver.d.ts

@@ -1,3 +1,5 @@
-import { TranscriptOptionsBase } from "discord-message-transcript-base";
+import { JsonAuthor, JsonMessage, TranscriptOptionsBase } from "discord-message-transcript-base";
 import { CDNOptions } from "../types/types.js";
-export declare function urlResolver(url: string, options: TranscriptOptionsBase, cdnOptions: CDNOptions<unknown> | null): Promise<string>;
+export declare function urlResolver(url: string, options: TranscriptOptionsBase, cdnOptions: CDNOptions | null, urlCache: Map<string, Promise<string>>): Promise<string>;
+export declare function messagesUrlResolver(messages: JsonMessage[], options: TranscriptOptionsBase, cdnOptions: CDNOptions | null, urlCache: Map<string, Promise<string>>): Promise<JsonMessage[]>;
+export declare function authorUrlResolver(authors: Map<string, JsonAuthor>, options: TranscriptOptionsBase, cdnOptions: CDNOptions | null, urlCache: Map<string, Promise<string>>): Promise<JsonAuthor[]>;

package/dist/core/urlResolver.js

@@ -1,9 +1,101 @@
+import { JsonComponentType } from "discord-message-transcript-base";
 import { cdnResolver } from "./cdnResolver.js";
 import { imageToBase64 } from "./imageToBase64.js";
-export async function urlResolver(url, options, cdnOptions) {
+import { isJsonComponentInContainer } from "./componentToJson.js";
+export async function urlResolver(url, options, cdnOptions, urlCache) {
+    if (urlCache.has(url)) {
+        const cache = urlCache.get(url);
+        if (cache)
+            return await cache;
+    }
+    let returnUrl;
     if (cdnOptions)
-        return await cdnResolver(url, cdnOptions);
-    if (options.saveImages)
-        return await imageToBase64(url);
+        returnUrl = cdnResolver(url, options, cdnOptions);
+    else if (options.saveImages)
+        returnUrl = imageToBase64(url);
+    if (returnUrl) {
+        urlCache.set(url, returnUrl);
+        return await returnUrl;
+    }
     return url;
 }
+export async function messagesUrlResolver(messages, options, cdnOptions, urlCache) {
+    return await Promise.all(messages.map(async (message) => {
+        const attachmentsPromise = Promise.all(message.attachments.map(async (attachment) => {
+            return {
+                ...attachment,
+                url: await urlResolver(attachment.url, options, cdnOptions, urlCache)
+            };
+        }));
+        const embedsPromise = Promise.all(message.embeds.map(async (embed) => {
+            return {
+                ...embed,
+                author: embed.author ? { ...embed.author, iconURL: embed.author.iconURL ? await urlResolver(embed.author.iconURL, options, cdnOptions, urlCache) : null } : null,
+                footer: embed.footer ? { ...embed.footer, iconURL: embed.footer.iconURL ? await urlResolver(embed.footer.iconURL, options, cdnOptions, urlCache) : null } : null,
+                image: embed.image?.url ? { url: await urlResolver(embed.image.url, options, cdnOptions, urlCache) } : null,
+                thumbnail: embed.thumbnail?.url ? { url: await urlResolver(embed.thumbnail.url, options, cdnOptions, urlCache) } : null,
+            };
+        }));
+        async function componentsFunction(components) {
+            return Promise.all(components.map(async (component) => {
+                if (component.type == JsonComponentType.Section) {
+                    if (component.accessory.type == JsonComponentType.Thumbnail) {
+                        return {
+                            ...component,
+                            accessory: {
+                                ...component.accessory,
+                                media: {
+                                    url: await urlResolver(component.accessory.media.url, options, cdnOptions, urlCache),
+                                }
+                            }
+                        };
+                    }
+                }
+                if (component.type == JsonComponentType.MediaGallery) {
+                    return {
+                        ...component,
+                        items: await Promise.all(component.items.map(async (item) => {
+                            return {
+                                ...item,
+                                media: { url: await urlResolver(item.media.url, options, cdnOptions, urlCache) },
+                            };
+                        }))
+                    };
+                }
+                if (component.type == JsonComponentType.File) {
+                    return {
+                        ...component,
+                        url: await urlResolver(component.url, options, cdnOptions, urlCache),
+                    };
+                }
+                if (component.type == JsonComponentType.Container) {
+                    return {
+                        ...component,
+                        components: (await componentsFunction(component.components)).filter(isJsonComponentInContainer), // Input components that are container-safe must always produce container-safe output.
+                    };
+                }
+                return component;
+            }));
+        }
+        const componentsPromise = componentsFunction(message.components);
+        const [attachments, embeds, components] = await Promise.all([
+            attachmentsPromise,
+            embedsPromise,
+            componentsPromise
+        ]);
+        return {
+            ...message,
+            attachments: attachments,
+            embeds: embeds,
+            components: components,
+        };
+    }));
+}
+export async function authorUrlResolver(authors, options, cdnOptions, urlCache) {
+    return await Promise.all(Array.from(authors.values()).map(async (author) => {
+        return {
+            ...author,
+            avatarURL: await urlResolver(author.avatarURL, options, cdnOptions, urlCache),
+        };
+    }));
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { CreateTranscriptOptions, ConvertTranscriptOptions, TranscriptOptions, ReturnType, CDNOptions, MimeType } from "./types/types.js";
 export { ReturnFormat, LocalDate, TimeZone } from "discord-message-transcript-base";
+export { setBase64Concurrency, setCDNConcurrency } from './core/limiter.js';
 import { TextBasedChannel } from "discord.js";
 import { ConvertTranscriptOptions, CreateTranscriptOptions, OutputType, ReturnType } from "./types/types.js";
 /**

package/dist/index.js

@@ -1,12 +1,14 @@
 export { ReturnType } from "./types/types.js";
 export { ReturnFormat } from "discord-message-transcript-base";
+export { setBase64Concurrency, setCDNConcurrency } from './core/limiter.js';
 import { AttachmentBuilder } from "discord.js";
 import { Json } from "./renderers/json/json.js";
 import { fetchMessages } from "./core/fetchMessages.js";
 import { ReturnType } from "./types/types.js";
 import { output } from "./core/output.js";
-import { ReturnTypeBase, ReturnFormat, outputBase, CustomError } from "discord-message-transcript-base";
+import { ReturnTypeBase, ReturnFormat, outputBase, CustomError, CustomWarn } from "discord-message-transcript-base";
 import { returnTypeMapper } from "./core/mappers.js";
+import { authorUrlResolver, messagesUrlResolver } from "./core/urlResolver.js";
 /**
  * Creates a transcript of a Discord channel's messages.
  * Depending on the `returnType` option, this function can return an `AttachmentBuilder`,
@@ -27,6 +29,11 @@ export async function createTranscript(channel, options = {}) {
         const artificialReturnType = options.returnType == ReturnType.Attachment ? ReturnTypeBase.Buffer : options.returnType ? returnTypeMapper(options.returnType) : ReturnTypeBase.Buffer;
         const { fileName = null, includeAttachments = true, includeButtons = true, includeComponents = true, includeEmpty = false, includeEmbeds = true, includePolls = true, includeReactions = true, includeV2Components = true, localDate = 'en-GB', quantity = 0, returnFormat = ReturnFormat.HTML, saveImages = false, selfContained = false, timeZone = 'UTC', watermark = true, } = options;
         const checkedFileName = (fileName ?? `Transcript-${channel.isDMBased() ? "DirectMessage" : channel.name}-${channel.id}`);
+        let validQuantity = true;
+        if (quantity < 0) {
+            CustomWarn("Quantity can't be a negative number, please use 0 for unlimited messages.\nUsing 0 as fallback!");
+            validQuantity = false;
+        }
         const internalOptions = {
             fileName: checkedFileName,
             includeAttachments,
@@ -38,7 +45,7 @@ export async function createTranscript(channel, options = {}) {
             includeReactions,
             includeV2Components,
             localDate,
-            quantity,
+            quantity: validQuantity ? quantity : 0,
             returnFormat,
             returnType: artificialReturnType,
             saveImages,
@@ -46,26 +53,63 @@ export async function createTranscript(channel, options = {}) {
             timeZone,
             watermark
         };
-        const jsonTranscript = channel.isDMBased() ? new Json(null, channel, internalOptions) : new Json(channel.guild, channel, internalOptions);
-        let lastMessageID;
+        const urlCache = new Map();
         const authors = new Map();
         const mentions = {
             channels: new Map(),
             roles: new Map(),
             users: new Map(),
         };
+        const fetchMessageParameter = {
+            channel: channel,
+            options: internalOptions,
+            transcriptState: {
+                authors: authors,
+                mentions: mentions,
+            },
+            lastMessageId: undefined
+        };
+        const jsonTranscript = channel.isDMBased() ? new Json(null, channel, internalOptions, options.cdnOptions ?? null, urlCache) : new Json(channel.guild, channel, internalOptions, options.cdnOptions ?? null, urlCache);
         while (true) {
-            const { messages, end } = await fetchMessages(channel, internalOptions, options.cdnOptions ?? null, authors, mentions, lastMessageID);
+            const { messages, end, newLastMessageId } = await fetchMessages(fetchMessageParameter);
             jsonTranscript.addMessages(messages);
-            lastMessageID = messages[messages.length - 1]?.id;
-            if (end || (jsonTranscript.messages.length >= quantity && quantity != 0)) {
+            fetchMessageParameter.lastMessageId = newLastMessageId;
+            if (end || (jsonTranscript.getMessages().length >= quantity && quantity != 0)) {
                 break;
             }
         }
-        jsonTranscript.sliceMessages(quantity);
-        jsonTranscript.setAuthors(Array.from(authors.values()));
-        jsonTranscript.setMentions({ channels: Array.from(mentions.channels.values()), roles: Array.from(mentions.roles.values()), users: Array.from(mentions.users.values()) });
-        const result = await output(await jsonTranscript.toJson());
+        if (quantity > 0 && jsonTranscript.getMessages().length > quantity) {
+            jsonTranscript.sliceMessages(quantity);
+        }
+        if (options.cdnOptions) {
+            options.cdnOptions = {
+                includeAudio: true,
+                includeImage: true,
+                includeVideo: true,
+                includeOthers: true,
+                ...options.cdnOptions
+            };
+        }
+        if (options.cdnOptions || options.saveImages) {
+            await Promise.all([
+                (async () => {
+                    jsonTranscript.setAuthors(await authorUrlResolver(authors, internalOptions, options.cdnOptions ?? null, urlCache));
+                    authors.clear();
+                })(),
+                (() => {
+                    jsonTranscript.setMentions({ channels: Array.from(mentions.channels.values()), roles: Array.from(mentions.roles.values()), users: Array.from(mentions.users.values()) });
+                    mentions.channels.clear();
+                    mentions.roles.clear();
+                    mentions.users.clear();
+                })(),
+                (async () => {
+                    jsonTranscript.setMessages(await messagesUrlResolver(jsonTranscript.getMessages(), internalOptions, options.cdnOptions ?? null, urlCache));
+                })()
+            ]);
+        }
+        const outputJson = await jsonTranscript.toJson();
+        urlCache.clear();
+        const result = await output(outputJson);
         if (!options.returnType || options.returnType == "attachment") {
             if (!(result instanceof Buffer)) {
                 throw new CustomError("Expected buffer from output when *attachment* returnType is used.");

package/dist/renderers/json/json.d.ts

@@ -1,15 +1,20 @@
 import { Guild, TextBasedChannel } from "discord.js";
 import { ArrayMentions, JsonAuthor, JsonMessage, TranscriptOptionsBase, JsonData } from "discord-message-transcript-base";
+import { CDNOptions } from "../../types/types.js";
 export declare class Json {
-    guild: Guild | null;
-    channel: TextBasedChannel;
-    authors: JsonAuthor[];
-    messages: JsonMessage[];
-    options: TranscriptOptionsBase;
-    mentions: ArrayMentions;
-    constructor(guild: Guild | null, channel: TextBasedChannel, options: TranscriptOptionsBase);
+    private guild;
+    private channel;
+    private authors;
+    private messages;
+    private options;
+    private mentions;
+    private cdnOptions;
+    private urlCache;
+    constructor(guild: Guild | null, channel: TextBasedChannel, options: TranscriptOptionsBase, cdnOptions: CDNOptions | null, urlCache: Map<string, Promise<string>>);
     addMessages(messages: JsonMessage[]): void;
     sliceMessages(size: number): void;
+    setMessages(messages: JsonMessage[]): void;
+    getMessages(): JsonMessage[];
     setAuthors(authors: JsonAuthor[]): void;
     setMentions(mentions: ArrayMentions): void;
     toJson(): Promise<JsonData>;

package/dist/renderers/json/json.js

@@ -1,4 +1,5 @@
 import { BaseGuildTextChannel, DMChannel } from "discord.js";
+import { urlResolver } from "../../core/urlResolver.js";
 export class Json {
     guild;
     channel;
@@ -6,13 +7,17 @@ export class Json {
     messages;
     options;
     mentions;
-    constructor(guild, channel, options) {
+    cdnOptions;
+    urlCache;
+    constructor(guild, channel, options, cdnOptions, urlCache) {
         this.guild = guild;
         this.channel = channel;
         this.messages = [];
         this.options = options;
         this.authors = [];
         this.mentions = { channels: [], roles: [], users: [] };
+        this.cdnOptions = cdnOptions;
+        this.urlCache = urlCache;
     }
     addMessages(messages) {
         this.messages.push(...messages);
@@ -21,7 +26,13 @@ export class Json {
         if (size > this.messages.length || size == 0) {
             return;
         }
-        this.messages = this.messages.slice(0, size - 1);
+        this.messages = this.messages.slice(0, size);
+    }
+    setMessages(messages) {
+        this.messages = messages;
+    }
+    getMessages() {
+        return this.messages;
     }
     setAuthors(authors) {
         this.authors = authors;
@@ -31,11 +42,13 @@ export class Json {
     }
     async toJson() {
         const channel = await this.channel.fetch();
+        const channelImg = channel instanceof DMChannel ? channel.recipient?.displayAvatarURL() ?? "cdn.discordapp.com/embed/avatars/4.png" : channel.isDMBased() ? channel.iconURL() ?? (await channel.fetchOwner()).displayAvatarURL() : null;
         const guild = !channel.isDMBased() ? this.guild : null;
+        const guildIcon = guild?.iconURL();
         const guildJson = !guild ? null : {
             name: guild.name,
             id: guild.id,
-            icon: guild.iconURL(),
+            icon: guildIcon ? await urlResolver(guildIcon, this.options, this.cdnOptions, this.urlCache) : null,
         };
         return {
             options: this.options,
@@ -45,7 +58,7 @@ export class Json {
                 parent: channel.isDMBased() ? null : (channel.parent ? { name: channel.parent.name, id: channel.parent.id } : null),
                 topic: (channel instanceof BaseGuildTextChannel) ? channel.topic : null,
                 id: channel.id,
-                img: channel instanceof DMChannel ? channel.recipient?.displayAvatarURL() ?? "cdn.discordapp.com/embed/avatars/4.png" : channel.isDMBased() ? channel.iconURL() ?? (await channel.fetchOwner()).displayAvatarURL() : null,
+                img: channelImg ? await urlResolver(channelImg, this.options, this.cdnOptions, this.urlCache) : null,
             },
             authors: this.authors,
             messages: this.messages.reverse(),

package/dist/types/types.d.ts

@@ -1,19 +1,51 @@
 import { JsonMessageMentionsChannels, JsonMessageMentionsRoles, JsonMessageMentionsUsers, LocalDate, TimeZone, Uploadable, ReturnFormat } from "discord-message-transcript-base";
 import { AttachmentBuilder } from "discord.js";
 import Stream from 'stream';
+/**
+ * An enum-like object providing the possible return types for the transcript functions.
+ */
 export declare const ReturnType: {
+    /**
+     * Returns a `discord.js` AttachmentBuilder.
+     */
     readonly Attachment: "attachment";
+    /**
+     * Returns a `Buffer`.
+     */
     readonly Buffer: "buffer";
+    /**
+     * Returns a `Stream.Readable`.
+     * */
     readonly Stream: "stream";
+    /**
+     * Returns a `string`.
+     * */
     readonly String: "string";
+    /**
+     * Returns an `Uploadable` object with content, contentType, and fileName.
+     */
     readonly Uploadable: "uploadable";
 };
+/**
+ * The type representing the possible values of the `ReturnType` enum.
+ */
 export type ReturnType = typeof ReturnType[keyof typeof ReturnType];
+/**
+ * A conditional type that maps the `ReturnType` string literal to the actual TypeScript type returned by the function.
+ * @template T The `ReturnType` literal.
+ */
 export type OutputType<T extends ReturnType> = T extends typeof ReturnType.Buffer ? Buffer : T extends typeof ReturnType.Stream ? Stream : T extends typeof ReturnType.String ? string : T extends typeof ReturnType.Uploadable ? Uploadable : AttachmentBuilder;
+/**
+ * Options for creating a transcript, with all properties being optional.
+ * @see TranscriptOptions
+ */
 export type CreateTranscriptOptions<T extends ReturnType> = Partial<TranscriptOptions<T>>;
+/**
+ * Options for converting a JSON transcript to an HTML transcript.
+ */
 export type ConvertTranscriptOptions<T extends ReturnType> = Partial<{
     /**
-     * The type of the returned value.
+     * The desired output type for the transcript.
      * - ReturnType.Attachment - The transcript content as a `Attachment`
      * - ReturnType.String - The transcript content as a string.
      * - ReturnType.Buffer - The transcript content as a `Buffer`.
@@ -23,24 +55,27 @@ export type ConvertTranscriptOptions<T extends ReturnType> = Partial<{
      */
     returnType: T;
     /**
-     * Whether the generated HTML should be self-contained (CSS and JS in HTML).
+     * Whether the generated HTML should have its CSS and JS embedded directly in the file.
      * @default false
      */
     selfContained: boolean;
     /**
-     * If you want to include the watermark.
+     * Whether to include the 'Generated with discord-message-transcript' watermark in the footer.
      * @default true
      */
     watermark: boolean;
 }>;
-export interface TranscriptOptions<T extends ReturnType, Other = unknown> {
+/**
+ * Defines the complete set of options for creating a transcript.
+ */
+export interface TranscriptOptions<T extends ReturnType> {
     /**
-     * CDN Options
+     * Configuration for uploading attachments and other assets to a CDN.
      */
-    cdnOptions: CDNOptions<Other>;
+    cdnOptions: CDNOptions;
     /**
-     * The name of the file to be created.
-     * Default depends if is DM or Guild
+     * The name of the generated file (without extension).
+     * @default `Transcript-channel-name-channel-id`
      */
     fileName: string;
     /**
@@ -49,17 +84,17 @@ export interface TranscriptOptions<T extends ReturnType, Other = unknown> {
      */
     includeAttachments: boolean;
     /**
-     * Whether to include buttons in the transcript.
+     * Whether to include message component buttons in the transcript.
      * @default true
      */
     includeButtons: boolean;
     /**
-     * Whether to include components in the transcript.
+     * Whether to include non-button message components (like select menus) in the transcript.
      * @default true
      */
     includeComponents: boolean;
     /**
-     * Whether to include empty messages in the transcript.
+     * Whether to include messages that have no content.
      * @default false
      */
     includeEmpty: boolean;
@@ -74,23 +109,23 @@ export interface TranscriptOptions<T extends ReturnType, Other = unknown> {
      */
     includePolls: boolean;
     /**
-     * Whether to include reactions in the transcript.
+     * Whether to include message reactions in the transcript.
      * @default true
      */
     includeReactions: boolean;
     /**
-     * Whether to include V2 components in the transcript.
+     * Whether to include newer (V2) components like `Container`, `MediaGallery`, etc.
      * @default true
      */
     includeV2Components: boolean;
     /**
-     * The locale to use for formatting dates.
-     * Can be any BCP 47 language tag.
+     * The locale to use for formatting dates (e.g., 'en-US', 'pt-BR').
+     * Must be a valid BCP 47 language tag.
      * @default 'en-GB'
      */
     localDate: LocalDate;
     /**
-     * The maximum number of messages to fetch. Set to 0 to fetch all messages.
+     * The maximum number of messages to fetch. Set to `0` to fetch all messages in the channel.
      * @default 0
      */
     quantity: number;
@@ -102,7 +137,7 @@ export interface TranscriptOptions<T extends ReturnType, Other = unknown> {
      */
     returnFormat: ReturnFormat;
     /**
-     * The type of the returned value.
+     * The desired output type for the transcript.
      * - ReturnType.Attachment - The transcript content as a `Attachment`
      * - ReturnType.String - The transcript content as a string.
      * - ReturnType.Buffer - The transcript content as a `Buffer`.
@@ -112,48 +147,128 @@ export interface TranscriptOptions<T extends ReturnType, Other = unknown> {
      */
     returnType: T;
     /**
-     * Whether to save images locally or use remote URLs.
+     * Whether to save images as base64 data directly in the transcript.
+     * This is an alternative to using a CDN and results in larger file sizes.
+     * Will not work if using CDN.
      * @default false
      */
     saveImages: boolean;
     /**
-     * Whether the generated HTML should be self-contained.
-     * Only matters if `returnFormat` is `HTML`.
+     * Whether the generated HTML should have its CSS and JS embedded directly in the file.
+     * Only applicable if `returnFormat` is `HTML`.
      * @default false
      */
     selfContained: boolean;
     /**
-     * The timezone to use for formatting dates.
-     * Can be any IANA time zone name.
+     * The timezone to use for formatting dates (e.g., 'UTC', 'America/New_York').
+     * Must be a valid IANA time zone name.
      * @default 'UTC'
      */
     timeZone: TimeZone;
     /**
-     * If you want to include the watermark.
+     * Whether to include the 'Generated with discord-message-transcript' watermark in the footer.
      * @default true
      */
     watermark: boolean;
 }
+/**
+ * Defines the structure for storing discovered mentions (users, roles, channels) during transcript creation.
+ * Uses Maps for efficient lookups.
+ */
 export interface MapMentions {
     channels: Map<string, JsonMessageMentionsChannels>;
     roles: Map<string, JsonMessageMentionsRoles>;
     users: Map<string, JsonMessageMentionsUsers>;
 }
+/**
+ * A string template type for representing a MIME type (e.g., 'image/png', 'application/json').
+ */
 export type MimeType = `${string}/${string}`;
-export type CDNOptions<Other> = (Partial<{
+/**
+ * Base options applicable to all CDN providers.
+ */
+export type CDNBase = Partial<{
+    /**
+     * Whether to upload audio files to the CDN.
+     * @default true
+     */
     includeAudio: boolean;
+    /**
+     * Whether to upload image files (excluding GIFs) to the CDN.
+     * @default true
+     */
     includeImage: boolean;
+    /**
+     * Whether to upload video files (and GIFs) to the CDN.
+     * @default true
+     */
     includeVideo: boolean;
+    /**
+     * Whether to upload any other file types to the CDN.
+     * @default true
+     */
     includeOthers: boolean;
-}>) & ({
-    type: "CUSTOM";
-    customCdnResolver: (url: string, contentType: MimeType | null, other: Other) => Promise<string> | string;
-    other: Other;
-} | {
-    type: "CLOUDFLARE_R2";
-    accountId: string;
-    accessKey: string;
-    secretKey: string;
-    bucket: string;
-    publicUrl: string;
-});
+}>;
+/**
+ * A discriminated union of all possible CDN configurations.
+ */
+export type CDNOptions = (CDNBase & CDNOptionsCustom<any>) | (CDNBase & CDNOptionsCloudinary) | (CDNBase & CDNOptionsUploadcare);
+/**
+ * Configuration for using a custom, user-provided CDN resolver function.
+ */
+export type CDNOptionsCustom<T = unknown> = {
+    /** Specifies the use of a custom CDN resolver. */
+    provider: "CUSTOM";
+    /**
+     * An async function that takes a URL and returns a new URL.
+     * @param url The original Discord asset URL.
+     * @param contentType The MIME type of the asset.
+     * @param customData Any additional data you want to pass to your resolver.
+     * @returns The new URL of the asset on your CDN.
+     */
+    resolver: (url: string, contentType: MimeType | null, customData: T) => Promise<string> | string;
+    /**
+     * Any custom data you wish to make available within your resolver function.
+     */
+    customData: T;
+};
+/**
+ * Configuration for using Cloudinary as the CDN.
+ */
+export type CDNOptionsCloudinary = {
+    /**
+     * Specifies the use of the built-in Cloudinary provider.
+     */
+    provider: "CLOUDINARY";
+    /**
+     * Your Cloudinary cloud name.
+     */
+    cloudName: string;
+    /**
+     * Your Cloudinary API key.
+     * */
+    apiKey: string;
+    /**
+     * Your Cloudinary API secret.
+    */
+    apiSecret: string;
+};
+/**
+ * Configuration for using Uploadcare as the CDN.
+ */
+export type CDNOptionsUploadcare = {
+    /**
+     * Specifies the use of the built-in Uploadcare provider.
+     */
+    provider: "UPLOADCARE";
+    /**
+     * Your Uploadcare public key.
+     */
+    publicKey: string;
+    /**
+     * Your Uploadcare CDN domain.
+     * Example: "aaa111aaa1.ucarecd.net".
+     * DO NOT INCLUDE https://
+     */
+    cdnDomain: string;
+};

package/dist/types/types.js

@@ -1,7 +1,25 @@
+/**
+ * An enum-like object providing the possible return types for the transcript functions.
+ */
 export const ReturnType = {
+    /**
+     * Returns a `discord.js` AttachmentBuilder.
+     */
     Attachment: "attachment",
+    /**
+     * Returns a `Buffer`.
+     */
     Buffer: "buffer",
+    /**
+     * Returns a `Stream.Readable`.
+     * */
     Stream: "stream",
+    /**
+     * Returns a `string`.
+     * */
     String: "string",
+    /**
+     * Returns an `Uploadable` object with content, contentType, and fileName.
+     */
     Uploadable: "uploadable"
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-message-transcript",
-  "version": "1.2.0-dev.1.2.0.12.0",
+  "version": "1.2.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,11 +48,14 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "discord-message-transcript-base": "1.2.0-dev.1.2.0.12.0"
+    "discord-message-transcript-base": "1.2.0"
   },
   "peerDependencies": {
     "discord.js": ">=14.19.0 <15"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc"