djs-builder 0.4.85 → 0.5.0

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

@@ -1,15 +1,22 @@
 import { Client, Message, Collection, EmbedBuilder, TextChannel, PermissionResolvable } from 'discord.js';
 import { commands, aliases } from './prefix-register';
 import { PrefixOptions } from '../types/utils';
-import { getSimilarCommands } from '../functions/utils'
+import { getSimilarCommands } from '../functions/utils';
 import { botData } from './login';
+import { logError } from '../functions/logger'; 
 const cooldowns: Collection<string, Collection<string, number>> = new Collection();
 
-async function handleMessageCreate(message: Message, prefix: PrefixOptions): Promise<void> {
-    const botPrefix = prefix.prefix || '!';
+export async function handleMessageCreate(message: Message, prefixOptions: PrefixOptions): Promise<void> {
+    let botPrefix = prefixOptions.prefix || '!';
     const developers = botData.get('developers') as string[] | undefined;
     const ownerId = botData.get('ownerId') as string;
 
+    if (message.guild) {
+        const customPrefixEntry = prefixOptions.customPrefix?.find(entry => entry.serverId === message.guild?.id);
+        if (customPrefixEntry) {
+            botPrefix = customPrefixEntry.prefix;
+        }
+    }
     if (message.guild?.members.me) {
         const user = message.author;
         const botData = new Collection<string, string | string[]>();
@@ -17,132 +24,127 @@ async function handleMessageCreate(message: Message, prefix: PrefixOptions): Pro
 
         if (!message.guild.members.me.permissions.has('SendMessages')) {
             try {
-                user.send({ content:"I'm sorry, but I don't have permission to send messages in this server."});
-            } catch (error) {
+                user.send({ content: "I'm sorry, but I don't have permission to send messages in this server." });
+            } catch (error: any) {
+                logError("Failed to send permission error message to user.", error);
                 return;
             }
         }
-    
+
         if (permissionsArray && permissionsArray.length > 0) {
             const missingPermissions = permissionsArray.filter(permission => !message.guild?.members.me?.permissions.has(permission as PermissionResolvable));
-    
+
             if (missingPermissions.length > 0) {
                 try {
-                    user.send({ content:`I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.`});
-                } catch (error) {
+                    user.send({ content: `I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.` });
+                } catch (error: any) {
+                    logError("Failed to send missing permissions message to user.", error); // Log the error with details
                     return;
                 }
             }
         }
     }
-        
 
     if (!message.content.startsWith(botPrefix) || message.author.bot) return;
 
-    if (prefix.global === false && prefix.serverIds && prefix.serverIds.length > 0) {
-
+    if (prefixOptions.global === false && prefixOptions.serverIds && prefixOptions.serverIds.length > 0) {
         const guildId = message.guild?.id;
-        if (guildId && !prefix.serverIds.includes(guildId)) return;
-
+        if (guildId && !prefixOptions.serverIds.includes(guildId)) return;
     } else {
+        const args = message.content.slice(botPrefix.length).trim().split(/ +/);
+        const commandName = args.shift()?.toLowerCase();
 
-    const args = message.content.slice(botPrefix.length).trim().split(/ +/);
-    const commandName = args.shift()?.toLowerCase();
-
-    if (!commandName || (!commands.has(commandName) && !aliases.has(commandName))) return;
+        if (!commandName || (!commands.has(commandName) && !aliases.has(commandName))) return;
 
-    const command = commands.get(commandName) || commands.get(aliases.get(commandName) || '');
+        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.`);
+        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;
         }
-        return;
-    }
 
-    if (command.owner && message.author.id !== ownerId) {
-        await message.reply(`Only the bot owner can use this command.`);
-        return;
-    }
-
-
-    if (command.developer) {
-        if (developers && !developers.includes(message.author.id)) {
-            if (message.author.id === ownerId) return;
-            await message.reply("You are not authorized to use this command.");
+        if (command.owner && message.author.id !== ownerId) {
+            await message.reply(`Only the bot owner can use this command.`);
             return;
         }
-    }
 
+        if (command.developer) {
+            if (developers && !developers.includes(message.author.id)) {
+                if (message.author.id === ownerId) return;
+                await message.reply("You are not authorized to use this command.");
+                return;
+            }
+        }
 
-    const now = Date.now();
-    const timestamps = cooldowns.get(command.name) || new Collection<string, number>();
-    const cooldownAmount = (command.cooldown || 3) * 1000;
+        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 (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;
+            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);
+        timestamps.set(message.author.id, now);
+        setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);
+        cooldowns.set(command.name, timestamps);
 
+        try {
+            if (command.run) {
+                await command.run(message.client, message, args);
+            } else if (command.execute) {
+                await command.execute(message.client, message, args);
+            }
 
-    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] });
+            const channel = message.guild?.channels.cache.get(prefixOptions.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 (prefixOptions.logsId && channel) {
+                await channel.send({ embeds: [embedLog] });
+            }
+        } catch (error: any) {
+            logError(`Error executing command ${command.name}`, error);
         }
-    } catch (error) {
-        console.error(`⚠️ \x1b[33m%s Error executing command ${command.name}\x1b[0m:`, error);
     }
-  }
 }
 
 export async function loadPrefix(client: Client, prefix: PrefixOptions): Promise<void> {
     if (!prefix.prefix) {
-        throw new Error("⚠️ \x1b[33m%s No command prefix provided. Please provide a command prefix.\x1b[0m");
+        throw new Error("⚠️ No command prefix provided. Please provide a command prefix.");
     }
 
-    try { 
-        client.on("messageCreate", async message => await handleMessageCreate(message, prefix));
-    } catch (error) {
-        console.error('⚠️ \x1b[33m%s An error occurred while loading prefix\x1b[0m:', error);
+    try {
+        client.on("messageCreate", async (message) => await handleMessageCreate(message, prefix));
+    } catch (error: any) {
+        logError("An error occurred while loading prefix.", error);
     }
-}
+}

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

@@ -1,40 +1,54 @@
-import { logSuccess, logError, logInfo, logWarning } from '../functions/logger';
-import { commands, aliases, commandNames, readCommands } from './prefix-register';
+import { Collection } from 'discord.js';
+import { readdir } from 'fs/promises';
+import { join, resolve, extname } from 'path';
+import { commands, aliases, commandNames } from './prefix-register';
+import { readCommands } from './prefix-register'; 
+import { logError } from '../functions/logger';
 import { botData } from './login';
+const validExtensions = ['.js', '.ts'];
 
-export async function prefixLoader(client: any): Promise<boolean> {
-    const currentCommandNames = new Set(commands.keys());
-    console.log('Before clearing:');
-    console.log('Commands size:', commands.size);
-    console.log('Aliases size:', aliases.size);
-    console.log('Command names size:', commandNames.size);
-
-
-    commands.clear();
-    aliases.clear();
-    commandNames.clear();
+export async function prefixLoader(client: any): Promise<{ commands: Collection<string, any>; success: boolean }> {
+    try {
 
-    console.log('After clearing:');
-    console.log('Commands size:', commands.size);
-    console.log('Aliases size:', aliases.size);
-    console.log('Command names size:', commandNames.size);
-    const prefixPath = botData.get('prefixPath') as string;
+        const prefixPath =  botData.get('prefixPath') as string;
 
-    logInfo(`Reloading prefix commands from ${prefixPath}`);
+        commands.clear();
+        aliases.clear();
+        commandNames.clear();
+        client.prefixCommands = [];
+        client.prefixSize = 0;
 
-    try {
-        await readCommands(client, { path: prefixPath });
+        const resolvedPath = resolve(process.cwd(), prefixPath);
+        const dirents = await readdir(resolvedPath, { withFileTypes: true });
         
-        commands.forEach((_, name) => {
-            if (!currentCommandNames.has(name)) {
-                logWarning(`Removed old command: ${name}`);
+        const filePaths: string[] = [];
+        for (const dirent of dirents) {
+            if (dirent.isDirectory()) {
+                const folderPath = join(resolvedPath, dirent.name);
+                const files = await readdir(folderPath);
+                for (const file of files) {
+                    if (validExtensions.includes(extname(file))) {
+                        filePaths.push(join(folderPath, file));
+                    }
+                }
+            } else if (validExtensions.includes(extname(dirent.name))) {
+                filePaths.push(join(resolvedPath, dirent.name));
             }
-        });
+        }
 
-        logSuccess(`Successfully reloaded prefix commands.`);
-        return true;
+        for (const filePath of filePaths) {
+            delete require.cache[require.resolve(filePath)];
+        }
+
+        const commandDetails = await readCommands(client, { path: prefixPath });
+        client.prefixCommands = commandDetails;
+        client.prefixSize = commandDetails.length;
+        
+        return { commands: commands, success: true };
     } catch (error: any) {
-        logError(`Error reloading prefix commands: ${error.message}`);
-        return false;
+        logError('Error reloading commands:');
+        logError(error.message);
+
+        return { commands: new Collection(), success: false };
     }
 }

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

@@ -4,7 +4,7 @@ import { Routes } from 'discord-api-types/v10';
 import { readdir } from 'fs/promises';
 import path from 'path';
 import { SlashOptions } from '../types/starter';
-import { logSuccess, logError, logInfo } from '../functions/logger'; 
+import { logError } from '../functions/logger'; 
 
 export async function registerSlashCommands(client: any, token: string, slash: SlashOptions): Promise<Collection<string, any>> {
     if (!token) {
@@ -31,7 +31,6 @@ export async function registerSlashCommands(client: any, token: string, slash: S
                                 command.data.cooldown = command.cooldown || 0;
                             }
                             slashCommands.set(command.data.name, command);
-                            logInfo(`Loaded command: ${command.data.name}`);
                         }
                     } catch (error: any) {
                         logError(`Error in file: ${path.join(folderPath, file)}`);
@@ -46,7 +45,6 @@ export async function registerSlashCommands(client: any, token: string, slash: S
                             command.data.cooldown = command.cooldown || 0;
                         }
                         slashCommands.set(command.data.name, command);
-                        logInfo(`Loaded command: ${command.data.name}`);
                     }
                 } catch (error: any) {
                     logError(`Error in file: ${path.join(resolvedPath, dirent.name)}`);
@@ -58,24 +56,23 @@ export async function registerSlashCommands(client: any, token: string, slash: S
         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}` } });
-            logSuccess('Successfully registered global slash commands.');
         } 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}` } });
-                logSuccess(`Successfully registered guild slash commands for server ID: ${slash.serverId}`);
             } else {
                 logError(`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}` } });
-            logSuccess('Successfully registered global slash commands.');
         }
     } catch (error: any) {
         logError('Error registering slash commands:');
         logError(error.message);
+        console.error(error);
+
     }
 
     client.slashCommands = slashCommands;

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

@@ -118,6 +118,7 @@ export async function loadSlash(client: Client, token: string, options: SlashOpt
         } catch (error: any) {
             logError(`Error executing command "${command.data.name}":`);
             logError(error.message);
+            console.error(error);
             if (interaction.channel) {
                 await interaction.channel.send({ content: 'An error occurred while executing the command.' });
             }

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

@@ -1,19 +1,71 @@
-import { logSuccess, logError, logInfo } from '../functions/logger';
-import { registerSlashCommands } from './slash-register';
+import { Collection } from 'discord.js';
+import { REST } from '@discordjs/rest';
+import { Routes } from 'discord-api-types/v10';
+import { readdir } from 'fs/promises';
+import { resolve, extname } from 'path';
 import { botData } from './login';
+import { logError, logInfo } from '../functions/logger';
 
-export async function slashLoader(client: any, token: string, global: boolean, serverId?: string) {
-    client.slashCommands.clear();
-    const slashPath = botData.get('slashCommands') as string;
-
-    logInfo(`Reloading slash commands from ${slashPath}`);
+const validExtensions = ['.js', '.ts'];
 
+export async function slashLoader(client: any): Promise<{ commands: Collection<string, any>; success: boolean }> {
     try {
-        const newSlashCommands = await registerSlashCommands(client, token, { path: slashPath, global, serverId });
-        logSuccess(`Successfully reloaded ${newSlashCommands.size} slash commands.`);
-        return true
+        const slashPath = botData.get('slashCommandPath') as string;
+        const token = botData.get('botToken') as string;
+
+        const commandPath = resolve(process.cwd(), slashPath);
+
+        const getAllFiles = async (dirPath: string): Promise<string[]> => {
+            let files: string[] = [];
+            const dirents = await readdir(dirPath, { withFileTypes: true });
+
+            for (const dirent of dirents) {
+                const res = resolve(dirPath, dirent.name);
+                if (dirent.isDirectory()) {
+                    files = files.concat(await getAllFiles(res));
+                } else if (validExtensions.includes(extname(dirent.name))) {
+                    files.push(res);
+                }
+            }
+            return files;
+        };
+
+        const files = await getAllFiles(commandPath);
+        if (files.length === 0) {
+            logInfo(`No command files found in directory \`${commandPath}\`.`);
+            return { commands: new Collection<string, any>(), success: false };
+        }
+
+        for (const file of files) {
+            delete require.cache[require.resolve(file)];
+            logInfo(`Unlinked cached module: ${file}`);
+        }
+
+        const newCommands = new Collection<string, any>();
+        for (const file of files) {
+            try {
+                const command = require(file);
+                if (command.data) {
+                    client.slashCommands.set(command.data.name, command);
+                    newCommands.set(command.data.name, command);
+                }
+            } catch (error: any) {
+                logError(`Error re-importing file: ${file}`);
+                logError(error.message);
+            }
+        }
+
+        const rest = new REST({ version: '10' }).setToken(token);
+        const slashCommandArray = Array.from(newCommands.values()).map((command: any) => command.data.toJSON());
+
+        await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: [] });
+        await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: slashCommandArray });
+
+        return { commands: newCommands, success: true };
     } catch (error: any) {
-        logError(`Error reloading slash commands: ${error.message}`);
-        return false
+        logError('Error reloading slash commands:');
+        logError(error.message);
+        console.error(error);
+        return { commands: new Collection<string, any>(), success: false };
     }
 }

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

@@ -1,6 +1,5 @@
 import { StarterOptions, StarterInterface } from '../types/utils';
 import { mongoConnect, getDb, verseConnect } from '../functions/utils';
-import { loadEvents } from './events';
 const wait = require('node:timers/promises').setTimeout;
 import { login } from './login';
 import { AntiCrash } from '../functions/anticrash';
@@ -17,16 +16,13 @@ export class Starter implements StarterInterface {
             }
             if (options.bot?.Database?.verse) {
                 verseDb = await verseConnect(options.bot.Database.verse);
-            }
-            if (options.events) {
-                await loadEvents(djs, options.events);
-            }
-            if (options.anticrash?.enable) {
-              await AntiCrash(djs, options)
-            }            
+            }          
             if (options.bot) {
                 await login(djs, options);
             }
+            if (options.anticrash?.enable) {
+                await AntiCrash(djs, options)
+            }  
         } catch (error: any) {
             console.error('An error occurred during bot startup:', error.message);
             await this.handleStartupError(error, djs, options);

package/lib/discord/functions/logger.ts

@@ -9,6 +9,8 @@ const cyan = '\x1b[36m';
 const reset = '\x1b[0m';
 const yellow = '\x1b[33m';
 
+import { inspect } from 'util';
+
 
 function getTimestamp(): string {
     const now = new Date();
@@ -25,10 +27,18 @@ export function logSuccess(message: string) {
     console.log(`${getTimestamp()} ${green}${successEmoji}${reset} ${green}${message}${reset}`);
 }
 
-export function logError(message: string) {
-    console.error(`${getTimestamp()} ${red}${errorEmoji}${reset} ${red}${message}${reset}`);
+export function logError(message: string, error?: Error) {
+    const timestamp = getTimestamp();
+    const baseMessage = `${timestamp} ${red}${errorEmoji}${reset} ${red}${message}${reset}`;
+
+    if (error && error.stack) {
+        console.error(`${baseMessage}\n${error.stack}`);
+    } else {
+        console.error(baseMessage);
+    }
 }
 
+
 export function logInfo(message: string) {
     console.log(`${getTimestamp()} ${cyan}${infoEmoji}${reset} ${cyan}${message}${reset}`);
 }

package/lib/discord/types/starter.ts

@@ -47,6 +47,10 @@ export interface PrefixOptions {
     prefix: string;
     global?: boolean;
     serverIds?: string[];
+    customPrefix?: {
+        serverId: string;
+        prefix: string;
+    }[];
     logsId?: string;
 }
 

package/lib/discord/utils.ts

@@ -1,5 +1,13 @@
 import { Starter } from "./events-handler/starter";
 import { ButtonManager, MenuManager, PermissionChecker } from './builder/utils';
-import { prefixLoader } from "./events-handler/prefixLoader";
 import { slashLoader } from "./events-handler/slashLoader";
-export { Starter, ButtonManager, MenuManager, PermissionChecker, prefixLoader, slashLoader }
+import { prefixLoader } from "./events-handler/prefixLoader";
+import { eventLoader } from "./events-handler/eventLoader";
+import { readCommands } from "./events-handler/prefix-register";
+import { loadPrefix, handleMessageCreate } from "./events-handler/prefix-responder";
+import { registerSlashCommands } from "./events-handler/slash-register";
+import { loadSlash } from "./events-handler/slash-responder";
+import { loadEvents, withRetry, processEventFile, processDirectory, limitConcurrency, countEventFiles } from "./events-handler/events";
+export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile }

package/lib/index.ts

@@ -27,7 +27,14 @@ fetch("https://registry.npmjs.com/-/v1/search?text=djs-builder")
     .catch((e: any) => {});
 
 
-import { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader} from "./discord/utils";
+import { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile } from "./discord/utils";
 
-export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader };
-export default { Starter, ButtonManager, MenuManager, PermissionChecker, prefixLoader, slashLoader };
+export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile };
+export default { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
+    loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
+     processEventFile };
+export * from './discord/types/starter';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-builder",
-  "version": "0.4.85",
+  "version": "0.5.0",
   "description": "Discord.js bot builder. Supports Ts and Js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,6 +33,7 @@
     "cli-table": "^0.3.11",
     "colorette": "^2.0.20",
     "discord.js": "^14.15.3",
+    "djs-builder": "^0.4.10",
     "mongodb": "^6.5.0",
     "verse.db": "^2.0.4"
   },

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

@@ -1,21 +0,0 @@
-import { logSuccess, logError, logInfo } from '../functions/logger';
-import { EventsOptions } from '../types/starter';
-import { loadEvents } from './events'; 
-export async function eventsLoader(client: any, eventsOptions: EventsOptions) {
-
-    client.eventSize = 0;
-    client.removeAllListeners();
-
-    logInfo(`Reloading events from ${eventsOptions.path}`);
-
-    try {
-
-        await loadEvents(client, eventsOptions);
-
-        logSuccess(`Successfully reloaded ${client.eventSize} events.`);
-        return true
-    } catch (error: any) {
-        logError(`Error reloading events: ${error.message}`);
-        return false
-    }
-}