djs-builder 0.1.0

package/lib/discord/builder/utils.ts

@@ -0,0 +1,11 @@
+import { ButtonManager } from './components/Buttons';
+import { MenuManager } from './components/Menus';
+import { PermissionChecker } from './permissions/perms';
+
+const Components = {
+  ButtonManager,
+  MenuManager,
+  PermissionChecker
+};
+
+export { Components }

package/lib/discord/events-handler/events.ts

@@ -0,0 +1,75 @@
+import { Client } from 'discord.js';
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { EventsOptions } from '../types/utils';
+
+interface Event {
+    name: string;
+    once: boolean;
+    execute(...args: any[]): void;
+}
+
+async function processEventFile(client: Client, filePath: string, eventsOptions: EventsOptions) {
+    try {
+        const stats = await stat(filePath);
+        if (stats.isDirectory() && eventsOptions.recursive) {
+            const filesInDirectory = await readdir(filePath);
+            if (filesInDirectory.length === 0) {
+                return;
+            }
+            for (const item of filesInDirectory) {
+                const itemPath = join(filePath, item);
+                await processEventFile(client, itemPath, eventsOptions);
+            }
+        } else if (stats.isFile() && filePath.endsWith('.js')) {
+            const event: Event = await import(filePath);
+            if (eventsOptions.eventBlacklist && eventsOptions.eventBlacklist.includes(event.name)) {
+                console.log(`Event '${event.name}' is blacklisted and won't be loaded.`);
+                return;
+            }
+            if (event.once) {
+                client.once(event.name, (...args: any[]) => event.execute(...args, client));
+            } else {
+                client.on(event.name, (...args: any[]) => event.execute(...args, client));
+            }
+        }
+    } catch (error) {
+        console.error(`Error in event file: ${filePath}`);
+        console.error(error);
+    }
+}
+
+async function countEventFiles(filePath: string, eventsOptions: EventsOptions): Promise<number> {
+    let count = 0;
+    try {
+        const stats = await stat(filePath);
+        if (stats.isDirectory() && eventsOptions.recursive) {
+            const filesInDirectory = await readdir(filePath);
+            if (filesInDirectory.length === 0) {
+                return count;
+            }
+            for (const item of filesInDirectory) {
+                const itemPath = join(filePath, item);
+                count += await countEventFiles(itemPath, eventsOptions);
+            }
+        } else if (stats.isFile() && filePath.endsWith('.js')) {
+            count++;
+        }
+    } catch (error) {
+        console.error(`Error counting event files in directory: ${filePath}`);
+        console.error(error);
+    }
+    return count;
+}
+
+export async function loadEvents(client: any, eventsOptions: EventsOptions) {
+
+    try {
+        const eventSize = await countEventFiles(eventsOptions.path, eventsOptions);
+        client.eventSize = eventSize;
+        await processEventFile(client, eventsOptions.path, eventsOptions);
+    } catch (error) {
+        console.error(`Error while loading events from path: ${eventsOptions.path}`);
+        console.error(error);
+    }
+}

package/lib/discord/events-handler/login.ts

@@ -0,0 +1,117 @@
+import { Client, Collection, Routes, DataResolver, ActivityType } from 'discord.js';
+import { BotOptions } from '../types/starter';
+import * as path from 'path';
+
+export async function login(djs: Client, bot: BotOptions) { 
+
+    const botData = new Collection<string, string | string[]>();
+
+    if (!djs) {
+        throw new Error("\x1b[31mMissing client parameter. Please provide a valid Discord client.\x1b[0m");
+    }
+    if (bot.token) {
+        try {
+            await djs.login(bot.token);
+        } catch (error) {
+            console.error("\x1b[31mInvalid token provided. Please provide a valid bot token\x1b[0m");
+            process.exit(1);
+        }
+    }
+    djs.on('ready', async () => {
+        if (bot.name) djs.user?.setUsername(bot.name);
+        if (bot.avatar) {
+            const avatarPath = bot.avatar.startsWith('http') ? bot.avatar : path.join(process.cwd(), bot.avatar);
+            await djs.user?.setAvatar(avatarPath);
+        }
+        if (bot.banner) {
+            await djs.rest.patch(Routes.user(), {
+                body: { banner: await DataResolver.resolveImage(bot.banner) },
+            });
+        }
+
+        if (bot.BotInfo?.botInvite) {
+            botData.set('inviteURL', bot.BotInfo?.botInvite); 
+        }
+        if (bot.BotInfo && bot.BotInfo.perms) { 
+            botData.set('permissions', bot.BotInfo.perms); 
+        }
+        if (bot.BotInfo && bot.BotInfo.partners) {
+            botData.set('partners', bot.BotInfo.partners);
+        }        
+        if (bot.BotInfo && bot.BotInfo.ownerId) { 
+            botData.set('ownerId', bot.BotInfo.ownerId); 
+        }
+        if (bot.BotInfo && bot.BotInfo.serverId) { 
+            botData.set('serverId', bot.BotInfo.serverId); 
+        }
+        if (bot.BotInfo && bot.BotInfo.serverInvite) { 
+            botData.set('serverInvite', bot.BotInfo.serverInvite); 
+        }
+
+        if (bot.logs?.terminal) {
+            const { terminalLogs } = require('../functions/terminal');
+            terminalLogs(djs, bot); 
+        }
+
+        if (bot.logs?.devLogs?.enable) {
+            const { devLogger } = require('../functions/devLogs');
+            devLogger(bot.logs.devLogs); 
+        }
+
+        const userChosenType = bot.Status?.type || 3;
+        if (bot.Status?.activities) {
+            if (bot.Status.activities.length >= 1) {
+                const initialActivity = bot.Status.activities[0];
+                if (bot.Status.state === 'idle' || bot.Status.state === 'online' || bot.Status.state === 'dnd' || bot.Status.state === 'invisible') {
+                    djs.user?.setPresence({
+                    activities: [{ name: initialActivity, type: userChosenType }],
+                    status: bot.Status.state,
+                });
+              } else if (bot.Status.state === 'Streaming') {
+                djs.user?.setActivity({
+                    name: initialActivity,
+                    type: ActivityType.Streaming,
+                    url: 'https://www.twitch.tv/discord'
+                });
+              } else {
+                throw new Error('Invalid bot Status.');
+              }
+            }
+
+            if (bot.Status?.activities.length > 1) {
+                let delay = 60000; 
+                if (bot.Status.delay !== undefined) {
+                    if (bot.Status.delay < 60000) {
+                        throw new Error('Delay must be at least 1 minute.');
+                    }
+                    delay = bot.Status.delay;
+                }
+                setInterval(() => {
+                    try {
+                        const randomActivity: string | undefined = bot.Status?.activities?.[Math.floor(Math.random() * bot.Status.activities?.length)];
+                     
+                      if (randomActivity && bot.Status?.state === 'Streaming') {
+                            djs.user?.setActivity({
+                                name: randomActivity,
+                                type: ActivityType.Streaming,
+                                url: 'https://www.twitch.tv/discord'
+                            });
+                      } if (randomActivity && bot.Status?.state !== 'Streaming') {
+                            djs.user?.setPresence({
+                                activities: [{ name: randomActivity, type: userChosenType }],
+                                status: bot.Status?.state,
+                            });
+                      } 
+                    } catch (error) {
+                        console.error(`Error setting activity: ${error}`);
+                    }
+                }, delay);
+            }
+        } else if (bot.Status?.activities !== undefined){
+            throw new Error('Activities array must be provided.');
+        }
+        
+
+        (djs as any).botData = botData;
+    });
+}

package/lib/discord/events-handler/prefix-register.ts

@@ -0,0 +1,62 @@
+import { Collection } from 'discord.js';
+import { promises as fsPromises } from 'fs';
+import { join } from 'path';
+import { Command } from '../types/utils';
+
+export const commands = new Collection<string, Command>();
+export const aliases = new Collection<string, string>();
+export const commandNames = new Set<string>();
+
+export async function readCommands(client: any, folderPath: string): Promise<number> {
+    let prefixCommandCount = 0;
+
+    try {
+        await fsPromises.access(folderPath);
+        const files = await fsPromises.readdir(folderPath, { withFileTypes: true });
+
+        for (const file of files) {
+            const filePath = join(folderPath, file.name);
+
+            if (file.isDirectory()) {
+                prefixCommandCount += await readCommands(client, filePath);
+            } else if (file.isFile()) {
+                try {
+                    const command: Command = await import(filePath);
+                    if (command && (command.execute || command.run)) {
+                        commands.set(command.name, command);
+                        commandNames.add(command.name);
+
+                        if (command.aliases && Array.isArray(command.aliases)) {
+                            command.aliases.forEach(alias => {
+                                aliases.set(alias, command.name);
+                                commandNames.add(alias);
+                            });
+                        }
+
+                        command.description = command.description || "No description provided.";
+                        command.cooldown = command.cooldown || 1;
+                        command.usage = command.usage || "No usage information provided.";
+                        command.category = command.category || "Not categorized.";
+                        command.owner = command.owner || false;
+
+                        if (command.prefix) {
+                            prefixCommandCount++;
+                        }
+                    } else {
+                        console.warn(`Ignoring invalid command file: ${filePath}`);
+                    }
+                } catch (error) {
+                    console.error(`Error in file: ${filePath}`);
+                    console.error(error);
+                }
+            }
+        }
+        client.prefixSize = prefixCommandCount;
+
+        return prefixCommandCount;
+    } catch (error) {
+        console.error(`Error reading directory: ${folderPath}`);
+        console.error(error);
+        return 0;
+    }
+}

package/lib/discord/events-handler/prefix-responder.ts

@@ -0,0 +1,105 @@
+import { Client, Message, Collection, EmbedBuilder, TextChannel } from 'discord.js';
+import { commands, aliases } from './prefix-register';
+import { PrefixOptions } from '../types/utils';
+import { getSimilarCommands } from '../functions/utils'
+const botData = new Collection<string, string | string[]>();
+const ownerId = botData.get('ownerId') as string;
+const cooldowns: Collection<string, Collection<string, number>> = new Collection();
+
+async function handleMessageCreate(message: Message, prefix: PrefixOptions): Promise<void> {
+    const botPrefix = prefix.prefix || '!';
+    if (!message.content.startsWith(botPrefix) || message.author.bot) return;
+
+    if (prefix.global === false && prefix.serverIds && prefix.serverIds.length > 0) {
+
+        const guildId = message.guild?.id;
+        if (guildId && !prefix.serverIds.includes(guildId)) return;
+
+    } else {
+
+    const args = message.content.slice(botPrefix.length).trim().split(/ +/);
+    const commandName = args.shift()?.toLowerCase();
+
+    if (!commandName || (!commands.has(commandName) && !aliases.has(commandName))) return;
+
+    const command = commands.get(commandName) || commands.get(aliases.get(commandName) || '');
+
+    if (!command) {
+        const similarCommands = getSimilarCommands(commandName, commands);
+        if (similarCommands.length > 0) {
+            await message.reply(`Command not found. Did you mean: ${similarCommands.join(', ')}?`);
+        } else {
+            await message.reply(`Command '${commandName}' doesn't exist.`);
+        }
+        return;
+    }
+
+    if (command.owner && message.author.id !== ownerId) {
+        await message.reply(`Only the bot owner can use this command.`);
+        return;
+    }
+
+    const now = Date.now();
+    const timestamps = cooldowns.get(command.name) || new Collection<string, number>();
+    const cooldownAmount = (command.cooldown || 3) * 1000;
+
+    if (timestamps.has(message.author.id)) {
+        const expirationTime = timestamps.get(message.author.id) || 0;
+        const timeLeft = (expirationTime - now) / 1000;
+
+        if (now < expirationTime) {
+            await message.reply(`Please wait ${timeLeft.toFixed(1)} more second(s) before reusing the \`${command.name}\` command.`);
+            return;
+        }
+    }
+
+    timestamps.set(message.author.id, now);
+    setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);
+    cooldowns.set(command.name, timestamps);
+
+
+    try {
+        if (command.run) {
+             command.run(message.client, message, args);
+        } else if (command.execute) {
+             command.execute(message.client, message, args);
+        }
+
+        const channel = message.guild?.channels.cache.get(prefix.logsId || '') as TextChannel | undefined;
+        const userName = message.author.username;
+        const userId = message.author.id;
+        const serverName = message.guild?.name || null;
+        const serverId = message.guild?.id || null;
+        const messageLink = `https://discord.com/channels/${serverId}/${message.channel.id}/${message.id}`;
+    
+        const embedLog = new EmbedBuilder()
+            .setColor("Blue")
+            .setThumbnail(message.client.user?.displayAvatarURL())
+            .setTitle("Use Prefix Command")
+            .setTimestamp()
+            .addFields(
+                { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
+                { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
+                { name: "\u200B", value: "\u200B", inline: true },
+                { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
+                { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
+                { name: "\u200B", value: "\u200B", inline: true },
+                { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
+            );
+
+        if (prefix.logsId && channel) {
+            await channel.send({ embeds: [embedLog] });
+        }
+    } catch (error) {
+        console.error(`Error executing command ${command.name}:`, error);
+    }
+  }
+}
+
+export async function loadPrefix(client: Client, prefix: PrefixOptions): Promise<void> {
+    if (!prefix.prefix) {
+        throw new Error("No command prefix provided. Please provide a command prefix.");
+    }
+
+    client.on("messageCreate", async message => await handleMessageCreate(message, prefix));
+}

package/lib/discord/events-handler/slash-register.ts

@@ -0,0 +1,77 @@
+import { Collection, Guild } from 'discord.js';
+import { REST } from '@discordjs/rest';
+import { Routes } from 'discord-api-types/v10';
+import { readdir } from 'fs/promises';
+import path from 'path';
+import { SlashOptions } from '../types/starter';
+
+export async function registerSlashCommands(client: any, token: string, slash: SlashOptions): Promise<Collection<string, any>> {
+
+    if (!token) {
+        throw new Error("Please provide valid bot token to register slash commands.");
+    }
+
+    const slashCommands = new Collection<string, any>();
+    const rest = new REST({ version: '10' }).setToken(token);
+
+    try {
+        const resolvedPath = path.join(slash.baseDir, slash.path);
+        const dirents = await readdir(resolvedPath, { withFileTypes: true });
+
+        for (const dirent of dirents) {
+            if (dirent.isDirectory()) {
+                const folderPath = path.join(resolvedPath, dirent.name);
+                const files = await readdir(folderPath);
+
+                for (const file of files) {
+                    try {
+                        const command = require(path.join(folderPath, file));
+                        if (command.data) {
+                            if (command.cooldown && !isNaN(command.cooldown)) {
+                                command.data.cooldown = command.cooldown || 0;
+                            }
+                            slashCommands.set(command.data.name, command);
+                        }
+                    } catch (error) {
+                        console.error(`Error in file: ${path.join(folderPath, file)}`);
+                        console.error(error);
+                    }
+                }
+            } else {
+                try {
+                    const command = require(path.join(resolvedPath, dirent.name));
+                    if (command.data) {
+                        if (command.cooldown && !isNaN(command.cooldown)) {
+                            command.data.cooldown = command.cooldown || 0;
+                        }
+                        slashCommands.set(command.data.name, command);
+                    }
+                } catch (error) {
+                    console.error(`Error in file: ${path.join(resolvedPath, dirent.name)}`);
+                    console.error(error);
+                }
+            }
+        }
+
+        if (slash.global && !slash.serverId) {
+            const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
+            await rest.put(Routes.applicationCommands((client.user?.id || '')), { body: slashCommandArray, headers: { Authorization: `Bot ${token}` } });
+        } else if (!slash.global && slash.serverId) {
+            const guild = client.guilds.cache.get(slash.serverId) as Guild | undefined;
+            if (guild) {
+                const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
+                await rest.put(Routes.applicationGuildCommands((client.user?.id || ''), guild.id), { body: slashCommandArray, headers: { Authorization: `Bot ${token}` } });
+            } else {
+                console.error(`Guild with ID ${slash.serverId} not found.`);
+            }
+        } else {
+            const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
+            await rest.put(Routes.applicationCommands((client.user?.id || '')), { body: slashCommandArray, headers: { Authorization: `Bot ${token}` } });
+        }
+    } catch (error: any) {
+        console.error('Error registering slash commands:', error.message);
+    }
+
+    client.slashSize = slashCommands.size;
+    return slashCommands;
+}

package/lib/discord/events-handler/slash-responder.ts

@@ -0,0 +1,89 @@
+import { Client, Collection, Interaction, EmbedBuilder, Snowflake } from 'discord.js';
+import { registerSlashCommands } from './slash-register';
+import { SlashOptions } from '../types/starter';
+
+export async function loadSlash(client: Client, token: string, options: SlashOptions): Promise<void> {
+    const slashCommands = await registerSlashCommands(client, token, options);
+
+    if (!slashCommands || slashCommands.size === 0) {
+        console.log('\x1b[33m%s\x1b[0m', 'No registered slash commands. SlachHandler won\'t work.');
+        return;
+    }
+
+    const interactionCooldowns: Collection<Snowflake, Collection<string, number>> = new Collection();
+
+    client.on('interactionCreate', async (interaction: Interaction) => {
+        if (!interaction.isCommand() || !interaction.guild || !interaction.isChatInputCommand() || interaction.user.bot) {
+            return;
+        }
+
+        const command = slashCommands.get(interaction.commandName);
+        if (!command) return;
+
+        if (command.cooldown && !isNaN(command.cooldown)) {
+            const userCooldowns = interactionCooldowns.get(interaction.user.id) || new Collection<string, number>();
+            const cooldownExpiration = userCooldowns.get(command.data.name);
+            if (cooldownExpiration && cooldownExpiration > Date.now()) {
+                const remainingCooldown = (cooldownExpiration - Date.now()) / 1000;
+                await interaction.reply(`Command is on cooldown. Please wait ${remainingCooldown.toFixed(1)} seconds.`);
+                return;
+            }
+            userCooldowns.set(command.data.name, Date.now() + command.cooldown * 1000);
+            interactionCooldowns.set(interaction.user.id, userCooldowns);
+        }
+
+ 
+        try {
+            if (command.run) {
+                await command.run(client, interaction);
+            } else if (command.execute) {
+                await command.execute(client, interaction);
+            } else {
+                console.log('\x1b[33m%s\x1b[0m', `Command "${command.data.name}" has neither run nor execute method.`);
+            }
+            const startExecutionTime = Date.now();
+
+            const channel = interaction.guild.channels.cache.get(options.logsId || '') as any;
+            const userName = interaction.user.username;
+            const userId = interaction.user.id;
+            const serverName = interaction.guild.name || 'Unknown Server';
+            const serverId = interaction.guild.id || 'Unknown ID';
+            let messageLink = '';
+    
+            if (interaction.channel) {
+                messageLink = `https://discord.com/channels/${serverId}/${interaction.channel.id}/${interaction.id}`;
+            } else {
+                messageLink = 'Unknown';
+            }
+    
+    
+            const embedLog = new EmbedBuilder()
+            .setColor("Blue")
+            .setThumbnail(interaction.client.user?.displayAvatarURL())
+            .setTitle("Use Prefix Command")
+            .setTimestamp()
+            .addFields(
+                { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
+                { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
+                { name: "\u200B", value: "\u200B", inline: true },
+                { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
+                { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
+                { name: "\u200B", value: "\u200B", inline: true },
+                { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
+            );
+            if (options.logsId && channel) {
+                await channel.send({ embeds: [embedLog] });
+            }
+
+            const executionTime = Date.now() - startExecutionTime;
+            if (executionTime > 3000) {
+                console.log('\x1b[33m%s\x1b[0m', `Command "${command.data.name}" took ${executionTime}ms to execute.`);
+            }
+        } catch (error) {
+            console.error('\x1b[31m%s\x1b[0m', `Error executing command "${command.data.name}":`, error);
+            if (interaction.channel) {
+                await interaction.channel.send({ content: 'An error occurred while executing the command.' });
+            }
+        }
+    });
+}

package/lib/discord/events-handler/starter.ts

@@ -0,0 +1,56 @@
+import { StarterOptions, StarterInterface } from '../types/utils';
+import { loadEvents } from './events';
+import { loadPrefix } from './prefix-responder';
+import { loadSlash } from './slash-responder';
+import { mongoConnect, getDb, verseConnect } from '../functions/utils';
+import { login } from './login';
+
+export class Starter implements StarterInterface {
+    async start(djs: any, options: StarterOptions): Promise<any> {
+        let mongoDb;
+        let verseDb;
+
+        try {
+            if (options.bot) {
+                await login(djs, options.bot);
+            }
+            if (options.events) {
+                await loadEvents(djs, options.events);
+            }
+            if (options.prefix) {
+                await loadPrefix(djs, options.prefix);
+            }
+            if (options.slash && options.bot.token) {
+                await loadSlash(djs, options.bot?.token, options.slash);
+            }
+            if (options.bot?.Database?.mongo) {
+                await mongoConnect(options.bot.Database.mongo.mongoURI, options.bot.Database.mongo.dbName || 'djshandler');
+                mongoDb = await getDb();
+            }
+            if (options.bot?.Database?.verse) {
+                verseDb = await verseConnect(options.bot.Database.verse);
+            }
+            if (options.anticrash?.enable) {
+
+            }
+        } catch (error: any) {
+            console.error('An error occurred during bot startup:', error.message);
+            await this.handleStartupError(error, djs, options);
+        }
+
+        return {
+            mongodb: mongoDb,
+            versedb: verseDb,
+            slashSize: djs.slashSize || 0,
+            prefixSize: djs.prefixSize || 0,
+            eventSize: djs.eventSize || 0
+        };
+    }
+
+    async handleStartupError(error: any, djs: any, options: StarterOptions) {
+        console.error('Error during bot startup:', error);
+        setTimeout(() => {
+            this.start(djs, options);
+        }, 5000); 
+    }
+}

package/lib/discord/functions/anticrash.ts

@@ -0,0 +1,51 @@
+import { WebhookClient, EmbedBuilder } from 'discord.js';
+
+export async function AntiCrash(djs: any, options: any) {
+    try {
+        if (!options.AntiCrash.webhookURL) {
+            throw new Error('Please provide a valid webhook URL.');
+        }
+        const webhookClient = new WebhookClient({ url: options.AntiCrash.webhookURL });
+
+        process.on('uncaughtException', (error: any) => {
+            console.error('Uncaught Exception:');
+            console.error('Error:', error.message);
+            if (error.stack) {
+                console.error('Stack Trace:', error.stack);
+                const filenameMatch = error.stack.match(/\((.*?):\d+:\d+\)/);
+                const filename = filenameMatch ? filenameMatch[1] : 'Unknown File';
+
+                const embed = new EmbedBuilder()
+                    .setTitle('Uncaught Exception')
+                    .setDescription(`**File:** \`${filename}\`\n**Error:** \`${error.message}\`\n**Stack Trace:** \`\`\`${error.stack}\`\`\``)
+                    .setColor('#FF0000')
+                    .setTimestamp();
+
+                    webhookClient.send({ content: options.AntiCrash?.mention || '', embeds: [embed] });
+                }
+        });
+
+        process.on('unhandledRejection', (reason: any, promise: any) => {
+            console.error('Unhandled Rejection:');
+            console.error('Reason:', reason);
+            if (promise) {
+                console.error('Promise:', promise);
+            }
+        
+            const stackTrace = reason?.stack || '';
+            const filenameMatch = stackTrace.match(/at\s+(.+):(\d+):(\d+)/);
+            const filename = filenameMatch ? filenameMatch[1] : 'Unknown File';
+        
+            const embed = new EmbedBuilder()
+                .setTitle('Unhandled Rejection')
+                .setDescription(`**File:** \`${filename}\`\n**Reason:** \`${reason}\`\n**Promise:** \`${promise}\``)
+                .setColor('#FF0000')
+                .setTimestamp();
+        
+                webhookClient.send({ content: options.AntiCrash?.mention || '', embeds: [embed] });
+            });
+        
+    } catch (error: any) {
+        console.error('An error occurred in AntiCrash function:', error.message);
+    }
+}