djs-builder 0.5.31 → 0.5.40

package/lib/discord/builder/system/collectors.ts

@@ -0,0 +1,197 @@
+import {
+    Message,
+    Interaction,
+    MessageCollector,
+    InteractionCollector,
+    CollectorFilter,
+    Snowflake,
+    ReadonlyCollection,
+    CommandInteraction,
+    ButtonInteraction,
+    MessageReaction,
+    ModalSubmitInteraction,
+    StringSelectMenuInteraction,
+    UserSelectMenuInteraction,
+    RoleSelectMenuInteraction,
+    ContextMenuCommandInteraction,
+    Collector,
+} from 'discord.js';
+
+type EventSource = Message | CommandInteraction | ButtonInteraction | MessageReaction | Interaction;
+
+const collectorCache: Map<string, any> = new Map();
+
+/**
+ * @param sources - The event source(s) (message, interaction, reaction, etc.) to collect from.
+ * @param options - Custom options for collection (time, filter, max, idle).
+ * @param events - Custom event handlers for `onCollect`, `onEnd`, `onError`, etc.
+ */
+function Djs_Collectors<T extends EventSource>(
+    sources: T | T[],
+    options: {
+        time?: number; 
+        filter?: CollectorFilter<[T]>; 
+        max?: number; 
+        idle?: number; 
+        log?: boolean; 
+        throttle?: number; 
+        uniqueId?: string; 
+    },
+    events: {
+        onCollect: (collectedItem: T, meta?: Record<string, any>) => void; 
+        onEnd?: (collected: ReadonlyCollection<Snowflake, T>, reason: string) => void; 
+        onError?: (error: Error) => void; 
+        onDispose?: (disposedItem: T) => void; 
+        onTimeout?: () => void; 
+        onStart?: () => void; 
+    },
+    metadata?: Record<string, any> 
+): { stop: (reason?: string) => void } { 
+    const eventSources = Array.isArray(sources) ? sources : [sources];
+    const filter: CollectorFilter<[T]> = options.filter || (() => true);
+    const time: number = options.time || 60000; 
+
+    if (events.onStart) events.onStart();
+
+    if (options.uniqueId && collectorCache.has(options.uniqueId)) {
+        console.warn(`Collector with unique ID "${options.uniqueId}" is already active. Skipping creation.`);
+        return { stop: () => {} };
+    }
+
+    if (options.uniqueId) {
+        collectorCache.set(options.uniqueId, { sources: eventSources, time, max: options.max, idle: options.idle });
+    }
+
+    const collectors: any[] = []; 
+
+    for (const source of eventSources) {
+        if (source instanceof Message) {
+            const messageCollector = new MessageCollector(source.channel, {
+                filter: filter as CollectorFilter<[Message]>,
+                time,
+                max: options.max,
+                idle: options.idle,
+            });
+
+            collectors.push(messageCollector); // Store reference
+            handleCollector(messageCollector, events, options, metadata);
+
+        } else if (
+            source instanceof CommandInteraction ||
+            source instanceof ButtonInteraction ||
+            source instanceof StringSelectMenuInteraction ||
+            source instanceof UserSelectMenuInteraction ||
+            source instanceof RoleSelectMenuInteraction ||
+            source instanceof ContextMenuCommandInteraction ||
+            source instanceof ModalSubmitInteraction
+        ) {
+            if (!source.client.isReady()) {
+                throw new Error('Client is not ready. Please ensure the client is logged in and ready before creating a collector.');
+            }
+
+            const interactionCollector = new InteractionCollector(source.client, {
+                filter: filter as CollectorFilter<[Interaction]>,
+                time,
+                max: options.max,
+                idle: options.idle,
+            });
+
+            collectors.push(interactionCollector); // Store reference
+            handleCollector(interactionCollector, events, options, metadata);
+
+        } else if (source instanceof MessageReaction) {
+            const reactionCollector = source.message.createReactionCollector({
+                filter: filter as CollectorFilter<[MessageReaction]>,
+                time,
+                max: options.max,
+                idle: options.idle,
+            });
+
+            collectors.push(reactionCollector); // Store reference
+            handleCollector(reactionCollector, events, options, metadata);
+
+        } else {
+            throw new Error("Source must be either a Message, Interaction, or Reaction.");
+        }
+    }
+
+    return {
+        stop: (reason: string = 'manual') => {
+            if (options.uniqueId) {
+                const cached = collectorCache.get(options.uniqueId);
+                if (cached) {
+                    collectors.forEach((collector) => collector.stop(reason));
+                    collectorCache.delete(options.uniqueId);
+                    console.log(`Collector with unique ID "${options.uniqueId}" has been ended. Reason: ${reason}`);
+                } else {
+                    console.warn(`No collector found with unique ID "${options.uniqueId}".`);
+                }
+            } else {
+                collectors.forEach((collector) => collector.stop(reason)); 
+                console.log(`Collectors have been ended. Reason: ${reason}`);
+            }
+        },
+    };
+}
+
+/**
+ * Generic function to handle a collector's events and lifecycle.
+ * @param collector - The specific collector (MessageCollector, InteractionCollector, etc.).
+ * @param events - The event handlers for collection lifecycle.
+ * @param options - Additional collection options.
+ * @param metadata - Optional metadata attached to each collected item.
+ */
+function handleCollector<T>(
+    collector: any,
+    events: {
+        onCollect: (collectedItem: T, meta?: Record<string, any>) => void;
+        onEnd?: (collected: ReadonlyCollection<Snowflake, T>, reason: string) => void;
+        onError?: (error: Error) => void;
+        onDispose?: (disposedItem: T) => void;
+        onTimeout?: () => void;
+    },
+    options: { log?: boolean; throttle?: number; uniqueId?: string }, 
+    metadata?: Record<string, any>
+) {
+    let lastCollectedTime = 0; 
+
+    collector.on('collect', (collectedItem: T) => {
+        const now = Date.now();
+        if (options.throttle && now - lastCollectedTime < options.throttle) {
+            if (options.log) console.warn(`Throttled collect for ${collectedItem}`);
+            return; 
+        }
+        lastCollectedTime = now;
+
+        if (options.log) console.log('Collected item:', collectedItem);
+        events.onCollect(collectedItem, metadata);
+    });
+
+    collector.on('end', (collected: ReadonlyCollection<Snowflake, T>, reason: string) => {
+        if (options.log) console.log(`Collector ended. Reason: ${reason}`);
+        if (events.onEnd) events.onEnd(collected, reason);
+        if (reason === 'time' && events.onTimeout) {
+            events.onTimeout();
+        }
+
+        if (options.uniqueId) {
+            collectorCache.delete(options.uniqueId);
+        }
+    });
+
+    if (events.onError) {
+        collector.on('error', (error: Error) => {
+            if (options.log) console.error('Collector error:', error);
+            (events.onError as (error: Error) => void)(error);
+        });
+    }
+
+    if (events.onDispose) {
+        collector.on('dispose', (disposedItem: T) => {
+            if (options.log) console.log('Disposed item:', disposedItem);
+            (events.onDispose as (disposedItem: T) => void)(disposedItem);
+        });
+    }
+}
+
+export { Djs_Collectors };

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

@@ -1,9 +1,10 @@
-import { Collection } from 'discord.js';
+import { Client, Collection } from 'discord.js';
 import { readdir } from 'fs/promises';
 import { resolve, extname } from 'path';
 import { Event } from '../types/utils';
 import { logError, logInfo } from '../functions/logger';
 import { botData } from './login';
+import { watch } from 'fs';
 
 const validExtensions = ['.js', '.ts'];
 
@@ -136,3 +137,30 @@ async function withRetry(handler: (...args: any[]) => Promise<void>, retryAttemp
         logError('Reached maximum retry attempts.');
     };
 }
+
+export function autoEventLoader(client: Client, DEBOUNCE_DELAY: number = 10000, eventsOptions: Events = {}) {
+
+    const slashPath = botData.get('slashCommandPath') as string;
+    const commandPath = resolve(process.cwd(), slashPath);
+
+    let debounceTimer: NodeJS.Timeout | null = null;
+
+    const handleReload = async () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+            await eventLoader(client, eventsOptions);
+            logInfo('Slash commands successfully reloaded after debounce.');
+        }, DEBOUNCE_DELAY);
+    };
+
+    watch(commandPath, { recursive: false }, (eventType: any, filename: any) => {
+        if (filename && validExtensions.includes(extname(filename))) {
+            logInfo(`Detected ${eventType} in ${filename}, waiting for debouncing...`);
+            handleReload();
+        }
+    });
+
+    logInfo('Started watching for changes in slash commands...');
+}

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

@@ -7,6 +7,9 @@ import { GatewayIntentBits } from 'discord-api-types/v10';
 import { logError, logInfo, logWarning } from '../utils';
 import * as path from 'path';
 import fs from 'fs';
+import { autoSlashLoader } from './slashLoader';
+import { autoPrefixLoader } from './prefixLoader';
+import { autoEventLoader } from './eventLoader';
 
 export const botData = new Collection<string, string | string[]>();
 
@@ -248,5 +251,15 @@ export async function login(djs: Client & { botData?: Collection<string, string
         }
 
         (djs as any).botData = botData;
+
+        if (options.slash?.autoLoader?.enable) {
+            autoSlashLoader(djs, options.slash?.autoLoader?.DEBOUNCE_DELAY);
+        }
+        if (options.prefix?.autoLoader?.enable) {
+            autoPrefixLoader(djs, options.prefix?.autoLoader?.DEBOUNCE_DELAY);
+        }
+        if (options.events?.autoLoader?.enable) {
+            autoEventLoader(djs, options.events?.autoLoader?.DEBOUNCE_DELAY, options.events);
+        }
     });
 }

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

@@ -1,10 +1,11 @@
-import { Collection } from 'discord.js';
+import { Client, 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 { logError, logInfo } from '../functions/logger';
 import { botData } from './login';
+import { watch } from 'fs';
 const validExtensions = ['.js', '.ts'];
 
 export async function prefixLoader(client: any): Promise<{ commands: Collection<string, any>; success: boolean }> {
@@ -52,3 +53,31 @@ export async function prefixLoader(client: any): Promise<{ commands: Collection<
         return { commands: new Collection(), success: false };
     }
 }
+
+
+export function autoPrefixLoader(client: Client, DEBOUNCE_DELAY: number = 10000) {
+
+    const slashPath = botData.get('slashCommandPath') as string;
+    const commandPath = resolve(process.cwd(), slashPath);
+
+    let debounceTimer: NodeJS.Timeout | null = null;
+
+    const handleReload = async () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+            await prefixLoader(client);
+            logInfo('Slash commands successfully reloaded after debounce.');
+        }, DEBOUNCE_DELAY);
+    };
+
+    watch(commandPath, { recursive: false }, (eventType: any, filename: any) => {
+        if (filename && validExtensions.includes(extname(filename))) {
+            logInfo(`Detected ${eventType} in ${filename}, waiting for debouncing...`);
+            handleReload();
+        }
+    });
+
+    logInfo('Started watching for changes in slash commands...');
+}

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

@@ -4,7 +4,26 @@ import { Routes } from 'discord-api-types/v10';
 import { readdir } from 'fs/promises';
 import path from 'path';
 import { SlashOptions } from '../types/starter';
-import { logError } from '../functions/logger'; 
+import { logError } from '../functions/logger';
+
+async function loadCommand(filePath: string) {
+    try {
+        const command = require(filePath);
+        if (command.data) {
+            command.data.cooldown = command.cooldown && !isNaN(command.cooldown) ? command.cooldown : 0;
+            command.data.botPerms = command.botPerms || [];
+            command.data.userPerms = command.userPerms || [];
+            command.data.owner = command.owner || false;
+            command.data.developer = command.developer || false;
+            command.data.category = command.category || 'Uncategorized';
+            return command;
+        }
+    } catch (error: any) {
+        logError(`Error loading command from file: ${filePath}`);
+        logError(error.message);
+    }
+    return null;
+}
 
 export async function registerSlashCommands(client: any, token: string, slash: SlashOptions): Promise<Collection<string, any>> {
     if (!token) {
@@ -19,74 +38,41 @@ export async function registerSlashCommands(client: any, token: string, slash: S
         const dirents = await readdir(resolvedPath, { withFileTypes: true });
 
         for (const dirent of dirents) {
+            const folderPath = path.join(resolvedPath, dirent.name);
             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;
-                            }
-                            command.data.botPerms = command.botPerms || [];
-                            command.data.userPerms = command.userPerms || [];
-                            command.data.owner = command.owner || false;
-                            command.data.developer = command.developer || false;
-                            command.data.category = command.category || 'Uncategorized';
-
-
-                            slashCommands.set(command.data.name, command);
-                        }
-                    } catch (error: any) {
-                        logError(`Error in file: ${path.join(folderPath, file)}`);
-                        logError(error.message);
+                    const command = await loadCommand(path.join(folderPath, file));
+                    if (command) {
+                        slashCommands.set(command.data.name, command);
                     }
                 }
             } 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;
-                        }
-                        command.data.botPerms = command.botPerms || [];
-                        command.data.userPerms = command.userPerms || [];
-                        command.data.owner = command.owner || false;
-                        command.data.developer = command.developer || false;
-                        command.data.category = command.category || 'Uncategorized';
-
-
-                        slashCommands.set(command.data.name, command);
-                    }
-                } catch (error: any) {
-                    logError(`Error in file: ${path.join(resolvedPath, dirent.name)}`);
-                    logError(error.message);
+                const command = await loadCommand(path.join(resolvedPath, dirent.name));
+                if (command) {
+                    slashCommands.set(command.data.name, command);
                 }
             }
         }
 
+        const slashCommandArray = Array.from(slashCommands.values()).map(command => command.data.toJSON());
+
         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}` } });
+            await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: slashCommandArray });
         } 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}` } });
+                await rest.put(Routes.applicationGuildCommands(client.user?.id || '', guild.id), { body: slashCommandArray });
             } 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}` } });
+            await rest.put(Routes.applicationCommands(client.user?.id || ''), { body: slashCommandArray });
         }
     } 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

@@ -1,4 +1,11 @@
-import { Collection, Interaction, EmbedBuilder, Snowflake, PermissionResolvable, TextChannel } from 'discord.js';
+import {
+    Collection,
+    Interaction,
+    EmbedBuilder,
+    Snowflake,
+    PermissionResolvable,
+    TextChannel
+} from 'discord.js';
 import { registerSlashCommands } from './slash-register';
 import { SlashOptions } from '../types/starter';
 import { logWarning, logError, logInfo } from '../functions/logger';
@@ -14,41 +21,47 @@ export async function loadSlash(client: any, token: string, options: SlashOption
     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 || !interaction.isContextMenuCommand) {
+        // Ensure we are handling the correct type of interaction
+        if (!interaction.isCommand() && !interaction.isChatInputCommand() && !interaction.isContextMenuCommand()) {
             return;
         }
 
-        if (interaction.guild?.members.me) {
-            const user = interaction.user;
+        const guild = interaction.guild; // Get the guild once for better readability
+        const user = interaction.user;
+
+        if (guild) {
             const botData = new Collection<string, string | string[]>();
             const permissionsArray = botData.get('permissions') as string[] | undefined;
-        
-            if (!interaction.guild.members.me.permissions.has('SendMessages')) {
+
+            // Check if bot has permission to send messages
+            if (!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."});
+                    await user.send({ content: "I'm sorry, but I don't have permission to send messages in this server." });
                 } catch (error) {
-                    return;
+                    return; // Ignore errors when sending the message
                 }
             }
-        
+
+            // Check for missing permissions
             if (permissionsArray && permissionsArray.length > 0) {
-                const missingPermissions = permissionsArray.filter(permission => !interaction.guild?.members.me?.permissions.has(permission as PermissionResolvable));
-        
+                const missingPermissions = permissionsArray.filter(permission => !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.`});
+                        await user.send({ content: `I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.` });
                     } catch (error) {
-                        return;
+                        return; // Ignore errors when sending the message
                     }
                 }
             }
-        }    
+        }
 
         const commandName = interaction.commandName;
         const command = slashCommands.get(commandName);
 
         if (!command) return;
 
+        // Handle command cooldowns
         if (command.cooldown && !isNaN(command.cooldown)) {
             const userCooldowns = interactionCooldowns.get(interaction.user.id) || new Collection<string, number>();
             const cooldownExpiration = userCooldowns.get(command.data.name);
@@ -65,37 +78,29 @@ export async function loadSlash(client: any, token: string, options: SlashOption
 
         try {
             if (command.run) {
-                if (command.run.length === 2) {
-                  await command.run(interaction, client);
-                } else {
-                  await command.run(interaction);
-                }
-            }
-            else if (command.execute) {
-                if (command.execute.length === 2) {
-                  await command.execute(interaction, client);
-                } else {
-                  await command.execute(interaction);
-                }
+                await command.run.length === 2 ? command.run(interaction, client) : command.run(interaction);
+            } else if (command.execute) {
+                await command.execute.length === 2 ? command.execute(interaction, client) : command.execute(interaction);
             } else {
                 logWarning(`Command "${command.data.name}" has neither run nor execute method.`);
             }
 
-            if (options.logsId) {
-                const channel = interaction.guild.channels.cache.get(options.logsId as string) as TextChannel;
-                  if(channel) { 
-                    const userName = interaction.user.username;
-                    const userId = interaction.user.id;
-                    const serverName = interaction.guild.name || 'Unknown Server';
-                    const serverId = interaction.guild.id || 'Unknown ID';
+            // Logging command usage
+            if (options.logsId && guild) {
+                const channel = guild.channels.cache.get(options.logsId as string) as TextChannel;
+                if (channel) {
+                    const userName = user.username;
+                    const userId = user.id;
+                    const serverName = guild.name || 'Unknown Server';
+                    const serverId = 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())
@@ -110,9 +115,9 @@ export async function loadSlash(client: any, token: string, options: SlashOption
                             { name: "\u200B", value: "\u200B", inline: true },
                             { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
                         );
-        
-                    await channel.send({ embeds: [embedLog] });    
-                  }
+
+                    await channel.send({ embeds: [embedLog] });
+                }
             }
 
             const executionTime = Date.now() - startExecutionTime;

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

@@ -1,10 +1,11 @@
-import { Collection } from 'discord.js';
+import { Client, 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';
+import { watch } from 'fs';
 
 const validExtensions = ['.js', '.ts'];
 
@@ -74,3 +75,30 @@ export async function slashLoader(client: any): Promise<{ commands: Collection<s
         return { commands: new Collection<string, any>(), success: false };
     }
 }
+
+export function autoSlashLoader(client: Client, DEBOUNCE_DELAY: number = 10000) {
+
+    const slashPath = botData.get('slashCommandPath') as string;
+    const commandPath = resolve(process.cwd(), slashPath);
+
+    let debounceTimer: NodeJS.Timeout | null = null;
+
+    const handleReload = async () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+            await slashLoader(client);
+            logInfo('Slash commands successfully reloaded after debounce.');
+        }, DEBOUNCE_DELAY);
+    };
+
+    watch(commandPath, { recursive: false }, (eventType: any, filename: any) => {
+        if (filename && validExtensions.includes(extname(filename))) {
+            logInfo(`Detected ${eventType} in ${filename}, waiting for debouncing...`);
+            handleReload();
+        }
+    });
+
+    logInfo('Started watching for changes in slash commands...');
+}

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

@@ -4,7 +4,7 @@ const wait = require('node:timers/promises').setTimeout;
 import { botData, login } from './login';
 import { AntiCrash } from '../functions/anticrash';
 import { loadEvents } from './events';
-import { ShardingManager, ShardClientUtil } from 'discord.js';
+import { MessageCollector, InteractionCollector, ShardingManager, ShardClientUtil } from 'discord.js';
 import path from 'path';
 import fs from 'fs';
 import { logError, logInfo, logSuccess } from '../utils';
@@ -80,3 +80,6 @@ export class Starter implements StarterInterface {
         }, 5000); 
     }
 }
+
+
+

package/lib/discord/types/starter.ts

@@ -41,6 +41,10 @@ export interface SlashOptions {
     global?: boolean;
     serverId?: string;
     logsId?: string;
+    autoLoader?: {
+      enable?: boolean;
+      DEBOUNCE_DELAY?: number;
+    }
 }
 
 export interface PrefixOptions {
@@ -54,6 +58,10 @@ export interface PrefixOptions {
     }[];
     similarity?: boolean;
     logsId?: string;
+    autoLoader?: {
+        enable?: boolean;
+        DEBOUNCE_DELAY?: number;
+    }
 }
 
 export interface MongoDbOptions{
@@ -86,6 +94,10 @@ export interface EventsOptions {
     logsId?: string;
     recursive?: boolean;
     eventBlacklist?: string[];
+    autoLoader?: {
+        enable?: boolean;
+        DEBOUNCE_DELAY?: number;
+    }
 }
 
 export interface Event {

package/lib/discord/utils.ts

@@ -9,7 +9,9 @@ import { registerSlashCommands } from "./events-handler/slash-register";
 import { loadSlash } from "./events-handler/slash-responder";
 import { logError, logInfo, logSuccess, logWarning  } from "./functions/logger";
 import { Pagination } from "./builder/system/Pagination";
+import { Djs_Collectors } from "./builder/system/collectors";
 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, logError, logInfo, logSuccess, logWarning, Pagination }
+    processEventFile, logError, logInfo, logSuccess, logWarning, Pagination, Djs_Collectors };