discord-message-transcript 1.2.0-dev-next.0.20 → 1.2.0-dev.1.2.0.11.0

package/dist/core/cdnResolver.d.ts

@@ -1,4 +1,2 @@
 import { CDNOptions } from "../types/types.js";
-export declare function cdnResolver(url: string, cdnOptions: CDNOptions): Promise<string>;
-export declare function uploadCareResolver(url: string, publicKey: string): Promise<string>;
-export declare function cloudinaryResolver(url: string, cloudName: string, apiKey: string, apiSecret: string): Promise<string>;
+export declare function cdnResolver(url: string, cdnOptions: CDNOptions<unknown>): Promise<string>;

package/dist/core/cdnResolver.js

@@ -1,186 +1,56 @@
 import https from 'https';
 import http from 'http';
 import { CustomWarn } from "discord-message-transcript-base";
-import crypto from 'crypto';
-import { getCDNLimiter } from "./limiter.js";
 export async function cdnResolver(url, 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);
-                }
+    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) {
                 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));
-                }
+                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}.`);
                 return resolve(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}`);
+            }
+            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}.`);
                 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();
+            }
+            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.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.provider) {
+    switch (cdnOptions.type) {
         case "CUSTOM": {
-            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, cdnOptions.cloudName, cdnOptions.apiKey, cdnOptions.apiSecret);
-            ;
+            return await cdnOptions.customCdnResolver(url, contentType, cdnOptions.other);
         }
-        case "UPLOADCARE": {
-            return await uploadCareResolver(url, cdnOptions.publicKey);
+        case "CLOUDFLARE": {
+            return await cdnCloudflare();
         }
     }
 }
-function sleep(ms) {
-    return new Promise(r => setTimeout(r, ms));
-}
-export async function uploadCareResolver(url, publicKey) {
-    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://ucarecdn.com/${json.uuid}/`;
-        }
-        if (json.token) {
-            for (let i = 0; i < 10; i++) {
-                await sleep(500);
-                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://ucarecdn.com/${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, project settings, rate limits, and network access.
-URL: ${url}
-Error: ${error?.message ?? error}`);
-        return url;
-    }
-}
-export async function cloudinaryResolver(url, cloudName, apiKey, apiSecret) {
-    try {
-        const timestamp = Math.floor(Date.now() / 1000);
-        // signature SHA1
-        const signature = crypto
-            .createHash("sha1")
-            .update(`timestamp=${timestamp}${apiSecret}`)
-            .digest("hex");
-        const form = new FormData();
-        form.append("file", url);
-        form.append("api_key", apiKey);
-        form.append("timestamp", timestamp.toString());
-        form.append("signature", signature);
-        form.append("use_filename", "true");
-        form.append("unique_filename", "false");
-        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;
-    }
+async function cdnCloudflare() {
+    return ''; // TODO: Implement cloudflare cdn
 }

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 | null, urlCache: Map<string, Promise<string>>): Promise<JsonTopLevelComponent[]>;
+export declare function componentsToJson(components: TopLevelComponent[], options: TranscriptOptionsBase, cdnOptions: CDNOptions<unknown> | null): Promise<JsonTopLevelComponent[]>;

package/dist/core/componentToJson.js

@@ -2,7 +2,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, urlCache) {
+export async function componentsToJson(components, options, cdnOptions) {
     const processedComponents = await Promise.all(components.filter(component => !(!options.includeV2Components && component.type != ComponentType.ActionRow))
         .map(async (component) => {
         switch (component.type) {
@@ -54,7 +54,7 @@ export async function componentsToJson(components, options, cdnOptions, urlCache
             }
             case ComponentType.Container: {
                 const newOptions = { ...options, includeComponents: true, includeButtons: true };
-                const componentsJson = await componentsToJson(component.components, newOptions, cdnOptions, urlCache);
+                const componentsJson = await componentsToJson(component.components, newOptions, cdnOptions);
                 return {
                     type: JsonComponentType.Container,
                     components: componentsJson.filter(isJsonComponentInContainer), // Input components that are container-safe must always produce container-safe output.
@@ -67,14 +67,14 @@ export async function componentsToJson(components, options, cdnOptions, urlCache
                     type: JsonComponentType.File,
                     fileName: component.data.name ?? null,
                     size: component.data.size ?? 0,
-                    url: await urlResolver(component.file.url, options, cdnOptions, urlCache),
+                    url: await urlResolver(component.file.url, options, cdnOptions),
                     spoiler: component.spoiler,
                 };
             }
             case ComponentType.MediaGallery: {
                 const mediaItems = await Promise.all(component.items.map(async (item) => {
                     return {
-                        media: { url: await urlResolver(item.media.url, options, cdnOptions, urlCache) },
+                        media: { url: await urlResolver(item.media.url, options, cdnOptions) },
                         spoiler: item.spoiler,
                     };
                 }));
@@ -99,7 +99,7 @@ export async function componentsToJson(components, options, cdnOptions, urlCache
                     accessoryJson = {
                         type: JsonComponentType.Thumbnail,
                         media: {
-                            url: await urlResolver(component.accessory.media.url, options, cdnOptions, urlCache),
+                            url: await urlResolver(component.accessory.media.url, options, cdnOptions),
                         },
                         spoiler: component.accessory.spoiler,
                     };

package/dist/core/fetchMessages.d.ts

@@ -1,21 +1,7 @@
 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(ctx: FetchMessagesContext): Promise<{
+export declare function fetchMessages(channel: TextBasedChannel, options: TranscriptOptionsBase, cdnOptions: CDNOptions<unknown> | null, authors: Map<string, JsonAuthor>, mentions: MapMentions, after?: string): Promise<{
     messages: JsonMessage[];
     end: boolean;
-    newLastMessageId: string | undefined;
 }>;
-export type FetchMessagesContext = {
-    channel: TextBasedChannel;
-    options: TranscriptOptionsBase;
-    cdnOptions: CDNOptions | null;
-    transcriptState: TranscriptState;
-    lastMessageId: string | undefined;
-};
-type TranscriptState = {
-    authors: Map<string, JsonAuthor>;
-    mentions: MapMentions;
-    urlCache: Map<string, Promise<string>>;
-};
-export {};

package/dist/core/fetchMessages.js

@@ -2,10 +2,8 @@ import { EmbedType } from "discord.js";
 import { componentsToJson } from "./componentToJson.js";
 import { urlResolver } from "./urlResolver.js";
 import { getMentions } from "./getMentions.js";
-export async function fetchMessages(ctx) {
-    const { channel, options, cdnOptions, transcriptState, lastMessageId } = ctx;
-    const { authors, mentions, urlCache } = transcriptState;
-    const originalMessages = await channel.messages.fetch({ limit: 100, cache: false, before: lastMessageId });
+export async function fetchMessages(channel, options, cdnOptions, authors, mentions, after) {
+    const originalMessages = await channel.messages.fetch({ limit: 100, cache: false, after: after });
     const rawMessages = await Promise.all(originalMessages.map(async (message) => {
         const attachments = await Promise.all(message.attachments.map(async (attachment) => {
             return {
@@ -13,17 +11,17 @@ export async function fetchMessages(ctx) {
                 name: attachment.name,
                 size: attachment.size,
                 spoiler: attachment.spoiler,
-                url: await urlResolver(attachment.url, options, cdnOptions, urlCache),
+                url: await urlResolver(attachment.url, options, cdnOptions),
             };
         }));
         // 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, urlCache) : Promise.resolve(null),
-                    embed.thumbnail?.url ? urlResolver(embed.thumbnail.url, options, cdnOptions, urlCache) : Promise.resolve(null),
-                    embed.image?.url ? urlResolver(embed.image.url, options, cdnOptions, urlCache) : Promise.resolve(null),
-                    embed.footer?.iconURL ? urlResolver(embed.footer.iconURL, options, cdnOptions, urlCache) : Promise.resolve(null),
+                    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),
                 ]);
                 return {
                     author: embed.author ? { name: embed.author.name, url: embed.author.url ?? null, iconURL: authorIcon } : null,
@@ -41,7 +39,7 @@ export async function fetchMessages(ctx) {
             }));
         if (!authors.has(message.author.id)) {
             authors.set(message.author.id, {
-                avatarURL: await urlResolver(message.author.displayAvatarURL(), options, cdnOptions, urlCache),
+                avatarURL: await urlResolver(message.author.displayAvatarURL(), options, cdnOptions),
                 bot: message.author.bot,
                 displayName: message.author.displayName,
                 guildTag: message.author.primaryGuild?.tag ?? null,
@@ -53,7 +51,7 @@ export async function fetchMessages(ctx) {
                 system: message.author.system,
             });
         }
-        const components = await componentsToJson(message.components, options, cdnOptions, urlCache);
+        const components = await componentsToJson(message.components, options, cdnOptions);
         await getMentions(message, mentions);
         return {
             attachments: options.includeAttachments ? attachments : [],
@@ -91,10 +89,9 @@ export async function fetchMessages(ctx) {
             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, newLastMessageId };
+    return { messages, end };
 }
 function formatTimeLeftPoll(timestamp) {
     const now = new Date();

package/dist/core/imageToBase64.js

@@ -1,53 +1,43 @@
 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) {
-    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);
-                });
-            });
-            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 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);
+            });
+            response.on('end', () => {
+                const buffer = Buffer.concat(chunks);
+                const base64 = buffer.toString('base64');
+                resolve(`data:${contentType};base64,${base64}`);
             });
-            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}.`);
+            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}`);
                 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/urlResolver.d.ts

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

package/dist/core/urlResolver.js

@@ -1,19 +1,9 @@
 import { cdnResolver } from "./cdnResolver.js";
 import { imageToBase64 } from "./imageToBase64.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;
+export async function urlResolver(url, options, cdnOptions) {
     if (cdnOptions)
-        returnUrl = cdnResolver(url, cdnOptions);
-    else if (options.saveImages)
-        returnUrl = imageToBase64(url);
-    if (returnUrl) {
-        urlCache.set(url, returnUrl);
-        return await returnUrl;
-    }
+        return await cdnResolver(url, cdnOptions);
+    if (options.saveImages)
+        return await imageToBase64(url);
     return url;
 }

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-export { CreateTranscriptOptions, ConvertTranscriptOptions, TranscriptOptions, ReturnType, CDNOptions, MimeType } from "./types/types.js";
+export { CreateTranscriptOptions, ConvertTranscriptOptions, TranscriptOptions, ReturnType, CDNOptions, CDNType, 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,6 +1,5 @@
-export { ReturnType } from "./types/types.js";
+export { ReturnType, CDNType } 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";
@@ -48,42 +47,24 @@ export async function createTranscript(channel, options = {}) {
             watermark
         };
         const jsonTranscript = channel.isDMBased() ? new Json(null, channel, internalOptions) : new Json(channel.guild, channel, internalOptions);
+        let lastMessageID;
         const authors = new Map();
         const mentions = {
             channels: new Map(),
             roles: new Map(),
             users: new Map(),
         };
-        const urlCache = new Map();
-        const fetchMessageParameter = {
-            channel: channel,
-            options: internalOptions,
-            cdnOptions: options.cdnOptions ?? null,
-            transcriptState: {
-                authors: authors,
-                mentions: mentions,
-                urlCache: urlCache
-            },
-            lastMessageId: undefined
-        };
         while (true) {
-            const { messages, end, newLastMessageId } = await fetchMessages(fetchMessageParameter);
+            const { messages, end } = await fetchMessages(channel, internalOptions, options.cdnOptions ?? null, authors, mentions, lastMessageID);
             jsonTranscript.addMessages(messages);
-            fetchMessageParameter.lastMessageId = newLastMessageId;
+            lastMessageID = messages[messages.length - 1]?.id;
             if (end || (jsonTranscript.messages.length >= quantity && quantity != 0)) {
                 break;
             }
         }
-        urlCache.clear(); // Clean cache
-        if (quantity > 0 && jsonTranscript.messages.length > quantity) {
-            jsonTranscript.sliceMessages(quantity);
-        }
+        jsonTranscript.sliceMessages(quantity);
         jsonTranscript.setAuthors(Array.from(authors.values()));
-        authors.clear(); // Clean cache
         jsonTranscript.setMentions({ channels: Array.from(mentions.channels.values()), roles: Array.from(mentions.roles.values()), users: Array.from(mentions.users.values()) });
-        mentions.channels.clear(); // Clean cache
-        mentions.roles.clear(); // Clean cache
-        mentions.users.clear(); // Clean cache
         const result = await output(await jsonTranscript.toJson());
         if (!options.returnType || options.returnType == "attachment") {
             if (!(result instanceof Buffer)) {

package/dist/types/types.d.ts

@@ -37,7 +37,7 @@ export interface TranscriptOptions<T extends ReturnType, Other = unknown> {
     /**
      * CDN Options
      */
-    cdnOptions: CDNOptions;
+    cdnOptions: CDNOptions<Other>;
     /**
      * The name of the file to be created.
      * Default depends if is DM or Guild
@@ -139,26 +139,21 @@ export interface MapMentions {
     roles: Map<string, JsonMessageMentionsRoles>;
     users: Map<string, JsonMessageMentionsUsers>;
 }
+export declare const CDNType: {
+    readonly CUSTOM: "CUSTOM";
+    readonly CLOUDFLARE: "CLOUDFLARE";
+};
+export type CDNType = typeof CDNType[keyof typeof CDNType];
 export type MimeType = `${string}/${string}`;
-export type CDNBase = Partial<{
+export type CDNOptions<Other> = (Partial<{
     includeAudio: boolean;
     includeImage: boolean;
     includeVideo: boolean;
     includeOthers: boolean;
-}>;
-export type CDNOptions = (CDNBase & CDNOptionsCustom<any>) | (CDNBase & CDNOptionsCloudinary) | (CDNBase & CDNOptionsUploadcare);
-export type CDNOptionsCustom<T = unknown> = {
-    provider: "CUSTOM";
-    resolver: (url: string, contentType: MimeType | null, customData: T) => Promise<string> | string;
-    customData: T;
-};
-export type CDNOptionsCloudinary = {
-    provider: "CLOUDINARY";
-    cloudName: string;
-    apiKey: string;
-    apiSecret: string;
-};
-export type CDNOptionsUploadcare = {
-    provider: "UPLOADCARE";
-    publicKey: string;
-};
+}>) & ({
+    type: Exclude<CDNType, "CUSTOM">;
+} | {
+    type: "CUSTOM";
+    customCdnResolver: (url: string, contentType: MimeType | null, other: Other) => Promise<string> | string;
+    other: Other;
+});

package/dist/types/types.js

@@ -5,3 +5,7 @@ export const ReturnType = {
     String: "string",
     Uploadable: "uploadable"
 };
+export const CDNType = {
+    CUSTOM: "CUSTOM",
+    CLOUDFLARE: "CLOUDFLARE",
+};

package/package.json

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

package/dist/core/limiter.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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);
-            }
-        });
-    };
-}