djs-builder 0.5.32 → 0.5.40

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.isChatInputCommand()) {
+        // 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/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/utils.ts

@@ -9,8 +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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-builder",
-  "version": "0.5.32",
+  "version": "0.5.40",
   "description": "Discord.js bot builder. Supports Ts and Js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",