xernerx 2.5.0 → 2.6.2

package/main.js

@@ -4,6 +4,7 @@ const { Client } = require('./models/Client.js'),
     { MessageCommand } = require('./models/commands/MessageCommand.js'),
     { InteractionCommand } = require('./models/commands/InteractionCommand.js'),
     { Event } = require('./models/commands/Event.js'),
+    { Inhibitor } = require('./models/commands/Inhibitor.js'),
     { LanguageHandler } = require('./models/handlers/LanguageHandler.js'),
     { ContextMenuCommand } = require('./models/commands/ContextMenuCommand.js'),
     pkg = require('./package.json'),
@@ -28,6 +29,8 @@ module.exports = {
     // Events
     Event,
 
+    Inhibitor,
+
     // Discord
     Discord,
     i18next,

package/models/Client.js

@@ -1,88 +1,55 @@
 const Discord = require('discord.js');
 const { s } = require('@sapphire/shapeshift');
-const { color, config } = require('./utils/Functions.js');
+const { color } = require('./utils/Functions.js');
 const { CommandHandler } = require('./handlers/CommandHandler.js');
 const { EventHandler } = require('./handlers/EventHandler.js');
 const { LanguageHandler } = require('./handlers/LanguageHandler.js');
-const Loader = require('./handlers/Loader.js');
+const InhibitorHandler = require('./handlers/InhibitorHandler.js');
+const Handler = require('./handlers/Handler.js');
 
-/**
- * @param {string} guildId - Test guild ID. 
- * @param {boolean} global - Whether the bot should be globally or locally loaded. 
- * @param {string[]} prefix - An array of prefix'. 
- * @param {string[]} ownerId - An array of bot owners. 
- * @param {boolean} ignoreOwner - Whether the bot should ignore owner privileges. 
- * @param {number} defaultCooldown - A cooldown between each command in milliseconds. 
- * @returns Discord client ready to login.
- */
 class Client extends Discord.Client {
-    constructor(options = {}) {
+    constructor(options = {}, settings = {}, i18next = {}, config = {}) {
         super(options)
 
-        s.object({
-            // Required
-            guildId: s.string,
-            global: s.boolean,
+        this.client = new Discord.Client({ intents: options.intents });
 
-            // optionals
-            prefix: s.array(s.string).optional,
-            ownerId: s.array(s.string).optional,
-            ignoreOwner: s.boolean.optional,
-            defaultCooldown: s.number.optional,
-            cacheTime: s.number.optional,
-            userPermissions: s.array(s.string).optional,
-            clientPermissions: s.array(s.string).optional,
-            defer: s.object({
-                reply: s.boolean.optional,
-                ephemeral: s.boolean.optional
-            }).optional,
-        }).parse(options)
+        this.client.settings = s.object({
+            guildId: s.string.default(undefined),
+            global: s.boolean.default(false),
+            prefix: s.array(s.string).default([]),
+            ownerId: s.array(s.string).default([]),
+            ignoreOwner: s.boolean.default(false),
+            defaultCooldown: s.number.default(0),
+            cacheTime: s.number.default(300000),
+            userPermissions: s.array(s.string).default([]),
+            clientPermissions: s.array(s.string).default([]),
+            logging: s.union(s.boolean, s.array(s.string)).default(false),
+        }).parse(settings);
 
-        this.client = new Discord.Client({ intents: [options.intents || 0], partials: [options.partials] });
+        this.client.language = i18next;
 
-        this.client.settings = {
-            prefix: options.prefix || [],
+        this.client.color = color({ client: this.client, options: settings });
 
-            ownerId: options.ownerId || [],
+        this.client.config = config;
 
-            guildId: options.guildId || undefined,
+        this.client.data = {
+            messages: {},
 
-            global: options.global || false,
-
-            ignoreOwner: options.ignoreOwner || false,
-
-            defaultCooldown: options.defaultCooldown || 0,
-
-            logging: options.logging || undefined,
-
-            cacheTime: options.cacheTime || 300000,
-
-            userPermissions: options.userPermissions || [],
-
-            clientPermissions: options.clientPermissions || [],
-
-            defer: {
-                reply: options?.defer?.reply === undefined ? null : options?.defer?.reply,
-                ephemeral: options?.defer?.ephemeral === undefined ? null : options?.defer?.ephemeral
-            },
-        }
-
-        this.client.language = options.language;
-
-        this.client.color = color({ client: this.client, options: options });
-
-        this.client.config = config({ client: this.client, options: options });
-
-        this.client.messages = {};
+            cooldowns: {}
+        };
 
         this.client.modules = {
             commandHandler: new CommandHandler({ client: this.client }),
 
             eventHandler: new EventHandler({ client: this.client }),
 
-            languageHandler: new LanguageHandler(this.client),
+            inhibitorHandler: new InhibitorHandler(this.client),
+
+            languageHandler: new LanguageHandler(this.client)
+        }
 
-            loader: new Loader(this.client)
+        this.client.util = {
+            handler: new Handler(this.client)
         }
 
         return this.client;

package/models/commands/Inhibitor.js

@@ -0,0 +1,31 @@
+const { s } = require('@sapphire/shapeshift')
+
+/**
+ * @param {String} id - The id of the event. @required
+ * @param {object} options - of the event. @required
+ * @param {string} name - The name of the event. @required
+ * @param {boolean} once - Whether the event should be ran once or continuously.
+ */
+class Inhibitor {
+    constructor(id, options = {}) {
+        s.object({
+            name: s.string,
+            type: s.string
+        }).parse(options)
+
+        this.id = id;
+
+        this.name = options.name;
+
+        this.type = options.type || undefined;
+
+    }
+
+    check(event) {
+        /*
+        * Make your custom event here.
+        */
+    }
+}
+
+module.exports = { Inhibitor };

package/models/commands/MessageCommand.js

@@ -17,6 +17,7 @@ class MessageCommand {
             name: s.string,
             aliases: s.array(s.string).optional,
             description: s.string,
+            prefix: s.array(s.string).optional,
             info: s.string.optional,
             owner: s.boolean.optional,
             admin: s.boolean.optional,
@@ -34,9 +35,13 @@ class MessageCommand {
 
         this.id = id;
 
+        this.name = options.name;
+
         this.aliases = [options.name, ...(options.aliases ? options.aliases : [])];
 
-        this.type = options.type;
+        this.regex = options.regex instanceof RegExp ? String(options.regex) : undefined;
+
+        this.prefix = options.prefix || [];
 
         this.description = options.description || undefined;
 

package/models/events/interactionCreate.js

@@ -3,6 +3,7 @@ const { interactionArgs } = require('./../utils/Arguments.js');
 const { InteractionType } = require('discord.js')
 const { commandValidation } = require('./../utils/CommandValidation.js');
 const { interactionUtil } = require('./../utils/Util.js');
+const { inhibitorsValidation } = require('../utils/InhibitorsValidation.js');
 /**
  * @returns interaction command executor.
  */
@@ -16,12 +17,14 @@ class BuildInInteractionEvent extends Event {
     }
 
     async run(interaction) {
-        await interactionUtil(interaction)
+        await interactionUtil(interaction);
 
         if (interaction.type == InteractionType.ApplicationCommand) {
             if (interaction.client.commands.interaction.has(interaction.commandName)) {
                 let command = interaction.client.commands.interaction.get(interaction.commandName);
 
+                if (inhibitorsValidation(interaction, command)) return;
+
                 await this.defer(interaction, command);
 
                 command.client = interaction.client;
@@ -35,7 +38,9 @@ class BuildInInteractionEvent extends Event {
                 if (commandValidation(interaction, command)) return;
 
                 try {
-                    await command.exec(interaction, { group: group, subcommand: subcommand, args: args });
+                    if (command.conditions) return command.conditions(interaction, { group, subcommand, args });
+
+                    await command.exec(interaction, { group, subcommand, args });
 
                     return interaction.client.emit('commandRun', interaction, "interaction", command)
                 }
@@ -47,11 +52,15 @@ class BuildInInteractionEvent extends Event {
             if (interaction.client.commands.contextMenu.has(interaction.commandName)) {
                 let command = interaction.client.commands.contextMenu.get(interaction.commandName);
 
+                if (inhibitorsValidation(interaction)) return;
+
                 await this.defer(interaction, command);
 
                 command.client = interaction.client;
 
                 try {
+                    if (command.conditions) return command.conditions(interaction);
+
                     await command.exec(interaction);
 
                     return interaction.client.emit('commandRun', interaction, 'contextMenu', command);

package/models/events/messageCreate.js

@@ -2,6 +2,7 @@ const { Event } = require('../commands/Event.js');
 const { messageArgs } = require("./../utils/Arguments.js");
 const { commandValidation } = require('./../utils/CommandValidation.js');
 const { messageUtil } = require('../utils/Util.js');
+const { inhibitorsValidation } = require('../utils/InhibitorsValidation.js');
 
 /**
  * @returns message command executor.
@@ -17,33 +18,62 @@ class BuildInMessageEvent extends Event {
 
     async run(message) {
         if (!message.author.bot) {
+            await messageUtil(message, "create");
+
+            let commands = message.client.commands.message;
+
+            commands.filter(c => c.regex).map(async command => {
+                let regex = command.regex.split(/\//).slice(1);
+
+                regex = RegExp(...regex);
+
+                if (message.content.match(regex)) {
+                    try {
+                        if (command.conditions && (await command.conditions(message))) return;
+
+                        return await command.exec(message);
+                    }
+                    catch (error) {
+                        message.client.emit("error", message, error);
+                    }
+                };
+            })
+
             if (message?.client?.settings?.prefix?.length <= 0) return;
 
-            await messageUtil(message, "create");
+            commands.filter(c => !c.regex).map(async command => {
+                command?.prefix?.map(prefix => {
+                    this.commandCheck(message, prefix, command);
+                })
 
-            for (const prefix of message.client.settings.prefix) {
-                if (!message.content.startsWith(prefix)) continue;
+                message.client.settings.prefix.map(prefix => {
+                    this.commandCheck(message, prefix, command);
+                });
+            })
+        }
+    }
 
-                let command = message.content.replace(prefix, "").split(/ +/).shift().toLowerCase();
+    async commandCheck(message, prefix, command) {
+        for (const alias of command.aliases) {
+            if (message.content.split(/ +/)[0] !== prefix + alias) continue;
 
-                if (!message.client.commands.message.has(command) || command == '') return;
+            if (inhibitorsValidation(message, command)) break;
 
-                command = message.client.commands.message.get(command);
+            const args = await messageArgs({ message: message, command: command });
 
-                command.client = message.client;
+            if (commandValidation(message, command)) break;
 
-                const args = await messageArgs({ message: message, command: command });
+            try {
+                if (command.conditions && (await command.conditions(message, args))) break;
 
-                if (commandValidation(message, command)) return;
+                await command.exec(message, args);
 
-                try {
-                    await command.exec(message, args);
+                return message.client.emit('commandRun', message, 'message', command);
+            }
+            catch (error) {
+                message.client.emit("error", message, error);
 
-                    return message.client.emit('commandRun', message, 'message', command);
-                }
-                catch (error) {
-                    message.client.emit("error", message, error);
-                }
+                break;
             }
         }
     }

package/models/events/messageUpdate.js

@@ -2,6 +2,7 @@ const { Event } = require('../commands/Event.js');
 const { messageArgs } = require("./../utils/Arguments.js");
 const { commandValidation } = require('./../utils/CommandValidation.js');
 const { messageUtil } = require('../utils/Util.js');
+const { inhibitorsValidation } = require('../utils/InhibitorsValidation.js');
 
 /**
  * @returns message command executor.
@@ -16,37 +17,64 @@ class BuildInMessageUpdateEvent extends Event {
     }
 
     async run(oldMessage, newMessage) {
-        if (newMessage?.client?.settings?.prefix?.length <= 0) return;
+        if (!oldMessage.author.bot && !newMessage.author.bot) {
+            await messageUtil(newMessage, "edit");
 
-        await messageUtil(newMessage, "edit");
+            let commands = newMessage.client.commands.message;
 
-        if (!oldMessage.author.bot && !newMessage.author.bot) {
+            commands.filter(c => c.regex).map(async command => {
+                let regex = command.regex.split(/\//).slice(1);
+
+                regex = RegExp(...regex);
 
-            if (!newMessage.client.messages[newMessage.id] === undefined) return;
+                if (newMessage.content.match(regex)) {
+                    try {
+                        if (command.conditions && (await command.conditions(newMessage))) return;
 
-            for (const prefix of newMessage.client.settings.prefix) {
-                if (!newMessage.content.startsWith(prefix)) continue;
+                        return await command.exec(newMessage);
+                    }
+                    catch (error) {
+                        newMessage.client.emit("error", newMessage, error);
+                    }
+                };
+            })
 
-                let command = newMessage.content.replace(prefix, "").split(/ +/).shift().toLowerCase();
+            if (newMessage?.client?.settings?.prefix?.length <= 0) return;
 
-                if (!newMessage.client.commands.message.has(command) || command === '') return;
+            if (!newMessage.client.data.messages[newMessage.id] === undefined) return;
 
-                command = newMessage.client.commands.message.get(command);
+            commands.filter(c => !c.regex).map(async command => {
+                command?.prefix?.map(prefix => {
+                    this.commandCheck(newMessage, prefix, command);
+                })
 
-                command.client = newMessage.client;
+                newMessage.client.settings.prefix.map(prefix => {
+                    this.commandCheck(newMessage, prefix, command);
+                });
+            })
+        }
+    }
 
-                const args = await messageArgs({ message: newMessage, command: command });
+    async commandCheck(message, prefix, command) {
+        for (const alias of command.aliases) {
+            if (message.content.split(/ +/)[0] !== prefix + alias) continue;
 
-                if (commandValidation(newMessage, command)) return;
+            if (inhibitorsValidation(message, command)) break;
 
-                try {
-                    command.exec(newMessage, args);
+            const args = await messageArgs({ message: message, command: command });
 
-                    return newMessage.client.emit('commandRun', newMessage, 'message', command);
-                }
-                catch (error) {
-                    newMessage.client.emit("error", newMessage, error);
-                }
+            if (commandValidation(message, command)) break;
+
+            try {
+                if (command.conditions && (await command.conditions(message, args))) break;
+
+                await command.exec(message, args);
+
+                return message.client.emit('commandRun', message, 'message', command);
+            }
+            catch (error) {
+                message.client.emit("error", message, error);
+                break;
             }
         }
     }

package/models/events/readyOnce.js

@@ -36,12 +36,20 @@ class BuildInReadyOnceEvent extends Event {
                 loaded.push(event);
             }
 
+            for (const [id, inhibitor] of [...client.inhibitors]) {
+                inhibitor.runType = 'inhibitor';
+
+                loaded.push(inhibitor);
+            }
+
             console.table(loaded, client.settings.logging);
         }
         else {
             Object.entries(client.commands).map(([type, commands]) => {
                 console.info(logStyle(`Loaded ${type} commands: ${commands.map(command => command?.data?.name || command?.name || command?.id).join(', ')}`, "text", "cyan"));
             })
+
+            // add events and inhibitors;
         }
     }
 

package/models/handlers/CommandHandler.js

@@ -1,10 +1,5 @@
-const fs = require('fs');
 const Discord = require('discord.js');
-const { REST } = require('@discordjs/rest');
-const { Routes, GatewayVersion } = require('discord-api-types/v10');
-const { delay, logStyle } = require('dumfunctions')
-const paths = require("path");
-const Loader = require('./Loader.js');
+const Handler = require('./Handler.js');
 
 /**
  * @param {object} client - The client.
@@ -15,8 +10,6 @@ class CommandHandler {
 
         this.client = client;
 
-        this.commands = [];
-
         client.commands = {
             message: new Discord.Collection(),
 
@@ -25,7 +18,7 @@ class CommandHandler {
             contextMenu: new Discord.Collection()
         }
 
-        this.load = new Loader(client);
+        this.load = new Handler(client);
     }
 
     loadAllInteractionCommands(path, logging = false) {

package/models/handlers/EventHandler.js

@@ -56,9 +56,11 @@ class EventHandler {
     }
 
     emitter(type) {
-        if (type == 'client') return this.client;
-        if (type == 'rest') return this.client.rest;
-        else return eval(type)
+        const client = this.client;
+
+        if (type == 'client') return client;
+        if (type == 'rest') return client.rest;
+        else return eval(type);
     }
 }
 

package/models/handlers/Handler.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const Discord = require('discord.js');
+const { REST } = require('@discordjs/rest');
+const { Routes, GatewayVersion } = require('discord-api-types/v10');
+const { logStyle } = require('dumfunctions');
+const { importCommands, reimportCommands } = require('../utils/CommandsUtil.js');
+const { importInhibitors } = require('../utils/InhibitorsUtil.js');
+
+module.exports = class Handler {
+    constructor(client) {
+        this.client = client;
+
+        this.commands = [];
+    }
+
+    loadAllInteractionCommands(path, logging = false) {
+        const files = this.#readdir(path);
+
+        importCommands(this.client, path, files, this.commands, 'interaction');
+
+        this.#deployCommands("interaction commands", logging);
+    }
+
+    reloadAllInteractionCommands() {
+        reimportCommands(this.client, this.commands, "interaction");
+
+        return this.#redeployCommands()
+    }
+
+    loadAllContextMenuCommands(path, logging = false) {
+        const files = this.#readdir(path);
+
+        importCommands(this.client, path, files, this.commands, 'contextMenu');
+
+        this.#deployCommands("context menu commands", logging);
+    }
+
+    reloadAllContextMenuCommands() {
+        reimportCommands(this.client, this.commands, "contextMenu");
+
+        return this.#redeployCommands()
+    }
+
+    loadAllMessageCommands(path) {
+        const files = this.#readdir(path);
+
+        importCommands(this.client, path, files, this.commands, 'message');
+    }
+
+    reloadAllMessageCommands() {
+        return reimportCommands(this.client, this.commands, "message");
+    }
+
+    loadAllInhibitors(path) {
+        const files = this.#readdir(path);
+
+        importInhibitors(this.client, path, files);
+    }
+
+    #deployCommands(type, logging = false) {
+        this.client.once('ready', async client => {
+            const rest = new REST({ version: GatewayVersion }).setToken(client.token);
+
+            try {
+                if (client.settings.global == true) {
+                    if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} in ${(await client.guilds.fetch()).size} server(s) globally.`, 'text', 'purple'));
+                    rest.put(Routes.applicationCommands(client.user.id), {
+                        body: this.commands
+                    })
+                }
+                else {
+                    if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} locally.`, 'text', 'purple'));
+                    rest.put(Routes.applicationGuildCommands(client.user.id, client.settings.guildId), {
+                        body: this.commands
+                    })
+                }
+            }
+            catch (e) {
+                throw new Error(e)
+            }
+        })
+    }
+
+    #redeployCommands() {
+        const rest = new REST({ version: GatewayVersion }).setToken(this.client.token);
+
+        (async () => {
+            try {
+                if (this.client.settings.global == true) {
+                    rest.put(Routes.applicationCommands(this.client.user.id), {
+                        body: this.commands
+                    })
+                }
+                else {
+                    rest.put(Routes.applicationGuildCommands(this.client.user.id, this.client.settings.guildId), {
+                        body: this.commands
+                    })
+                }
+            }
+            catch (e) {
+                throw new Error(e)
+            }
+        })();
+
+        return this.commands;
+    }
+
+    #readdir(path) {
+        return fs.readdirSync(path).filter(file => file.endsWith('.js'));
+    }
+}

package/models/handlers/InhibitorHandler.js

@@ -0,0 +1,16 @@
+const Handler = require("./Handler");
+const Discord = require('discord.js');
+
+module.exports = class InhibitorHandler {
+    constructor(client) {
+        this.client = client;
+
+        client.inhibitors = new Discord.Collection();
+
+        this.load = new Handler(client);
+    }
+
+    loadAllInhibitors(path) {
+        this.load.loadAllInhibitors(path);
+    }
+}

package/models/utils/Arguments.js

@@ -27,16 +27,26 @@ module.exports = new class Arguments {
      * @returns argument options without having to make them yourself.
      */
     async messageArgs({ message: message, command: command }) {
-        let args = {}, separator = command.separator || ' ', i = 0;
+        let args = { flags: {} }, separator = command.separator || ' ', i = 0;
 
         if (!command.args) return;
 
-        for (const argument of command.args) {
+        command.args.filter(c => c.type == "flag").map(flag => {
+            for (const flg of message.content.matchAll(flag.content)) {
+                if (flag.content == flg) {
+                    message.content = message.content.replace(flag.content, "");
 
-            let content = message.content.replace(new RegExp(`${separator}${separator}+`, "g"), separator).split(separator).slice(i + 1);
+                    args.flags[flag.name] = true;
+                }
+            }
 
-            if (content.join(separator) != '') {
+            if (!args.flags[flag.name]) args.flags[flag.name] = false;
+        })
 
+        for (const argument of command.args) {
+            let content = message.content.split(/ +/).slice(1).join(separator).replace(new RegExp(`${separator}${separator}+`, "g"), separator).split(separator).slice(i);
+
+            if (content.join(separator) != '' && argument.type !== "flag") {
                 if (argument?.content?.includes(content[0])) {
                     args[argument.name] = content[0];
                 }
@@ -51,30 +61,39 @@ module.exports = new class Arguments {
 
                 else if (argument.type == 'boolean') {
                     if (content[0]?.toLowerCase() != 'true' && content[0]?.toLowerCase() != 'false') content[0] = undefined;
+
                     args[argument.name] = content[0];
                 }
 
                 else if (argument.type == 'user') {
-                    let user;
-                    try { user = await message.client.users.fetch(content[0].replace(/<@!?|>/g, "")) } catch (e) { user = e }
+                    let user = message.client.users.cache.find(u => u?.username?.toLowerCase()?.includes(content[0]));
+
+                    try { user = await message.client.users.fetch(user?.id || content[0].replace(/<@!?|>/g, "")) } catch (e) { user = new Error("Invalid user snowflake ID") };
+
                     args[argument.name] = user;
                 }
 
                 else if (argument.type == 'role') {
-                    let role;
-                    try { role = await message.guild.roles.fetch(content[0].replace(/<@&?|>/g, "")) } catch (e) { role = e }
+                    let role = message.guild.roles.cache.find(r => r?.name?.toLowerCase()?.includes(content[0]));
+
+                    try { role = await message.guild.roles.fetch(role?.id || content[0].replace(/<@&?|>/g, "")) } catch (e) { role = new Error("Invalid role snowflake ID") };
+
                     args[argument.name] = role;
                 }
 
                 else if (argument.type == 'member') {
-                    let member;
-                    try { member = await message.guild.members.fetch(content[0].replace(/<@!?|>/g, "")) } catch (e) { member = e }
+                    let member = message.guild.members.cache.find(m => m?.nickname?.toLowerCase()?.includes(content[0]) || m?.user?.username?.toLowerCase()?.includes(content[0]));
+
+                    try { member = await message.guild.members.fetch(member?.id || content[0].replace(/<@!?|>/g, "")) } catch (e) { member = new Error("Invalid member snowflake ID") };
+
                     args[argument.name] = member;
                 }
 
                 else if (argument.type == 'channel') {
-                    let channel;
-                    try { channel = await message.client.channels.fetch(content[0].replace(/<#|>/g, "")) } catch (e) { channel = e }
+                    let channel = message.guild.channels.cache.find(c => c?.name?.toLowerCase()?.includes(content[0]));
+
+                    try { channel = await message.client.channels.fetch(channel?.id || content[0].replace(/<#|>/g, "")) } catch (e) { channel = new Error("Invalid channel snowflake ID") }
+
                     args[argument.name] = channel;
                 }
 
@@ -88,12 +107,12 @@ module.exports = new class Arguments {
                     else if (argument.prompt.send) return message.channel.send(argument.prompt.send);
                 }
 
-                else args[argument.name] = undefined;
+                else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
 
                 i++
             }
 
-            else args[argument.name] = undefined;
+            else args[argument.name] = typeof argument.default == 'function' ? argument.default(message) : argument.default;
         }
 
         return args;

package/models/utils/CommandValidation.js

@@ -1,8 +1,6 @@
 const Discord = require('discord.js');
 const { toPascalCase } = require('dumfunctions');
 
-const Cooldown = {};
-
 module.exports = new class CommandValidation {
     commandValidation(event, command, res = false) {
         function emit(reason, extra) {
@@ -11,16 +9,16 @@ module.exports = new class CommandValidation {
 
         if ((command?.ignoreOwner || event?.client?.settings?.ignoreOwner) && event?.client?.settings?.ownerId?.includes((event.user || event.author).id)) return res;
 
-        if (Cooldown[(event.user || event.author).id]) {
+        if (event.client.data.cooldowns[(event.user || event.author).id]) {
             res = true;
-            return emit("command on cooldown", (Cooldown[(event.user || event.author).id] - (event.editedTimestamp || event.createdTimestamp)));
+            return emit("command on cooldown", (event.client.data.cooldowns[(event.user || event.author).id] - (event.editedTimestamp || event.createdTimestamp)));
         }
 
-        if (!Cooldown[(event.user || event.author).id]) {
-            Cooldown[(event.user || event.author).id] = ((event.editedTimestamp || event.createdTimestamp) + (command.cooldown || event.client.settings.defaultCooldown || 0));
+        if (!event.client.data.cooldowns[(event.user || event.author).id]) {
+            event.client.data.cooldowns[(event.user || event.author).id] = ((event.editedTimestamp || event.createdTimestamp) + (command.cooldown || event.client.settings.defaultCooldown || 0));
 
             setTimeout(() => {
-                delete Cooldown[(event.user || event.author).id]
+                delete event.client.data.cooldowns[(event.user || event.author).id]
             }, command.cooldown || event?.client?.settings?.defaultCooldown || 0);
         }
 
@@ -60,13 +58,13 @@ module.exports = new class CommandValidation {
                 if (!event?.member?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
             }
 
-            if (missingPerms.length >= 1) {
+            if (missingPerms?.length >= 1) {
                 res = true;
                 return emit("missing user permissions", missingPerms);
             }
         }
 
-        if (event?.guild && command?.clientPermissions.length >= 1 || event.client.settings.clientPermissions.length >= 1) {
+        if (event?.guild && command?.clientPermissions?.length >= 1 || event?.client?.settings?.clientPermissions?.length >= 1) {
             let missingPerms = [];
 
             for (const permission of command?.clientPermissions) {

package/models/utils/CommandsUtil.js

@@ -0,0 +1,70 @@
+const { logStyle } = require("dumfunctions");
+
+module.exports = new class CommandsUtil {
+    importCommands(client, path, files, commands, type) {
+        for (const file of files) {
+            try {
+                let filepath = `${require("path").resolve(path)}/${file}`;
+
+                let command = require(filepath);
+
+                command = new command;
+
+                command.filepath = filepath;
+
+                command.runType = type;
+
+                command.client = client;
+
+                if (type !== 'message') {
+                    commands.push(command.data.toJSON());
+
+                    client.commands[type].set(command.data.name, command);
+                }
+
+                if (type === 'message') {
+                    client.commands[type].set(command.name, command);
+                }
+            }
+            catch (error) {
+                console.error(logStyle(`Couldn't load ${file} because of <${error.message}>!`, "text", "red"));
+            }
+        }
+
+        return commands;
+    }
+
+    reimportCommands(client, cmds, type) {
+        let commands = [];
+
+        client.commands[type].map(command => { if (!commands.includes(command.filepath)) commands.push(command.filepath) });
+
+        client.commands[type].sweep(() => true);
+
+        commands.map(path => {
+            delete require.cache[require.resolve(path)];
+
+            let command = require(path);
+
+            command = new command;
+
+            command.filepath = path;
+
+            command.runType = type;
+
+            command.client = client;
+
+            if (type !== 'message') {
+                cmds.push(command.data.toJSON());
+
+                client.commands[type].set(command.data.name, command);
+            }
+
+            if (type === 'message') {
+                client.commands[type].set(command.name, command);
+            }
+        })
+
+        return commands;
+    }
+}

package/models/utils/Functions.js

@@ -1,6 +1,7 @@
 const colors = require('../data/colors.json');
 const { EmbedBuilder, ActionRowBuilder, SelectMenuBuilder, Embed, ButtonBuilder, ButtonStyle } = require('discord.js');
 const opts = require('../data/options.json');
+const { logStyle } = require('dumfunctions');
 
 function reply(interaction, text) {
     return (interaction.replied || interaction.deferred) ? interaction.editReply(text) : interaction.reply(text);
@@ -152,7 +153,7 @@ module.exports = new class Functions {
 
                             else {
                                 commandInfo = {
-                                    name: command?.data?.name || command?.id,
+                                    name: command?.data?.name || command?.name || command?.id,
                                     description: command?.data?.description || command?.description,
                                     category: command.category
                                 }
@@ -162,7 +163,7 @@ module.exports = new class Functions {
 
                     else {
                         commandInfo = {
-                            name: command?.data?.name || command?.id,
+                            name: command?.data?.name || command?.name || command?.id,
                             description: command?.data?.description || command?.description,
                             category: command.category
                         }
@@ -175,7 +176,7 @@ module.exports = new class Functions {
             return cmds;
         }
 
-        if (!cmd) return [interaction?.commandName || interaction.content?.replace(interaction.client.settings.prefix.find(p => interaction.content.startsWith(p)), "").split(/ +/)[0], interaction?.options?._group, interaction?.options?._subcommand].join(' ').replace(/  +/g, " ").trim();
+        if (!cmd) return [interaction?.commandName || interaction.name || interaction.content?.replace(interaction.client.settings.prefix.find(p => interaction.content.startsWith(p)), "").split(/ +/)[0], interaction?.options?._group, interaction?.options?._subcommand].join(' ').replace(/  +/g, " ").trim();
     }
 
     buttonPaginator(interaction, embeds, options = {}) {

package/models/utils/InhibitorsUtil.js

@@ -0,0 +1,24 @@
+const { logStyle } = require('dumfunctions');
+
+module.exports = new class InhibitorsUtil {
+    importInhibitors(client, path, files) {
+        for (const file of files) {
+            try {
+                let filepath = `${require("path").resolve(path)}/${file}`;
+
+                let inhibitor = require(filepath);
+
+                inhibitor = new inhibitor;
+
+                inhibitor.filepath = filepath;
+
+                inhibitor.client = client;
+
+                client.inhibitors.set(inhibitor.name, inhibitor);
+            }
+            catch (error) {
+                console.error(logStyle(`Couldn't load ${file} because of <${error.message}>!`, "text", "red"));
+            }
+        }
+    }
+}

package/models/utils/InhibitorsValidation.js

@@ -0,0 +1,40 @@
+module.exports = new class InhibitorValidation {
+    inhibitorsValidation(event, command) {
+        let inhibited = {};
+
+        if (event.client.inhibitors.has(command.runType)) {
+            let inhibitor = event.client.inhibitors.get(command.runType);
+
+            inhibited[command.runType] = inhibitor.check(event);
+        }
+
+        if (event.client.inhibitors.has("member")) {
+
+            let inhibitor = event.client.inhibitors.get("member");
+
+            inhibited["member"] = inhibitor.check(event, event.member);
+        }
+
+        if (event.client.inhibitors.has("guild")) {
+            let inhibitor = event.client.inhibitors.get("guild");
+
+            inhibited["guild"] = inhibitor.check(event, event.guild);
+        }
+
+        if (event.client.inhibitors.has("user")) {
+            let inhibitor = event.client.inhibitors.get("user");
+
+            inhibited["user"] = inhibitor.check(event, event.user || event.author);
+        }
+
+        if (event.client.inhibitors.has("channel")) {
+            let inhibitor = event.client.inhibitors.get("channel");
+
+            inhibited["channel"] = inhibitor.check(event);
+        }
+
+        for (const inhibit of Object.values(inhibited)) {
+            if (inhibit) return inhibited;
+        }
+    }
+}

package/models/utils/Util.js

@@ -3,7 +3,7 @@ const { selectMenuPaginator, buttonPaginator, commandName, uptime, reply } = req
 module.exports = new class Util {
     async messageUtil(message, type) {
         setTimeout(() => {
-            if (message.client.messages[message.id] === null || message.client.messages[message.id]) delete message.client.messages[message.id];
+            if (message.client.data.messages[message.id] === null || message.client.data.messages[message.id]) delete message.client.data.messages[message.id];
 
             if (message.channel.messages.cache.has(message.id)) message.channel.messages.cache.delete(message.id);
         }, message.client.settings.cacheTime);
@@ -16,12 +16,12 @@ module.exports = new class Util {
         }
 
         if (type == "create") {
-            message.client.messages[message.id] = null;
+            message.client.data.messages[message.id] = null;
 
             message.util.send = async (e) => {
                 const msg = await message.channel.send(e);
 
-                message.client.messages[message.id] = msg.id;
+                message.client.data.messages[message.id] = msg.id;
 
                 return msg;
             }
@@ -29,7 +29,7 @@ module.exports = new class Util {
             message.util.reply = async (e) => {
                 const msg = await message.reply(e);
 
-                message.client.messages[message.id] = msg.id;
+                message.client.data.messages[message.id] = msg.id;
 
                 return msg;
             }
@@ -38,11 +38,11 @@ module.exports = new class Util {
         }
 
         if (type == 'edit') {
-            if (message.client.messages[message.id] === null) {
+            if (message.client.data.messages[message.id] === null) {
                 message.util.send = async (e) => {
                     const msg = await message.channel.send(e);
 
-                    message.client.messages[message.id] = msg.id;
+                    message.client.data.messages[message.id] = msg.id;
 
                     return msg;
                 }
@@ -50,7 +50,7 @@ module.exports = new class Util {
                 message.util.reply = async (e) => {
                     const msg = await message.reply(e);
 
-                    message.client.messages[message.id] = msg.id;
+                    message.client.data.messages[message.id] = msg.id;
 
                     return msg;
                 }
@@ -58,8 +58,8 @@ module.exports = new class Util {
                 return;
             }
 
-            else if (message.client.messages[message.id] !== null) {
-                const msg = await message.channel.messages.fetch(message.client.messages[message.id]);
+            else if (message.client.data.messages[message.id] !== null) {
+                const msg = await message.channel.messages.fetch(message.client.data.messages[message.id]);
 
                 message.util.send = async (e) => {
                     try {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xernerx",
-	"version": "2.5.0",
+	"version": "2.6.2",
 	"description": "A bot framework for discord.js. [BETA]",
 	"main": "main.js",
 	"scripts": {
@@ -17,10 +17,10 @@
 	},
 	"homepage": "https://github.com/TheDummi/xernerx#readme",
 	"dependencies": {
-		"@discordjs/rest": "1.0.1",
+		"@discordjs/rest": "1.1.0",
 		"@sapphire/shapeshift": "3.5.1",
-		"discord-api-types": "^0.37.3",
-		"discord.js": "^14.2.0",
+		"discord-api-types": "^0.37.5",
+		"discord.js": "^14.3.0",
 		"dumfunctions": "^1.0.7",
 		"i18next": "^21.9.1"
 	},

package/models/handlers/Loader.js

@@ -1,218 +0,0 @@
-const fs = require('fs');
-const Discord = require('discord.js');
-const { REST } = require('@discordjs/rest');
-const { Routes, GatewayVersion } = require('discord-api-types/v10');
-const { logStyle } = require('dumfunctions');
-
-class Loader {
-    constructor(client) {
-        this.client = client;
-
-        this.commands = [];
-
-        client.commands = {
-            message: new Discord.Collection(),
-
-            interaction: new Discord.Collection(),
-
-            contextMenu: new Discord.Collection()
-        }
-    }
-
-    loadAllInteractionCommands(path, logging = false) {
-        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'))
-
-        for (const file of commandFiles) {
-            try {
-                let filepath = `${require("path").resolve(path)}/${file}`
-
-                let command = require(filepath);
-
-                command = new command;
-
-                command.filepath = filepath;
-
-                this.commands.push(command.data.toJSON());
-
-                this.client.commands.interaction.set(command.data.name, command);
-            }
-            catch (error) {
-                console.error(logStyle(`Couldn't load ${file} because of <${error.message}>!`, "text", "red"));
-            }
-        }
-
-        this.#deployCommands("interaction commands", logging);
-    }
-
-    reloadAllInteractionCommands() {
-        let commands = this.client.commands.interaction.map(command => command.filepath);
-
-        this.commands = [];
-
-        this.client.commands.interaction.sweep(() => true);
-
-        commands.map(path => {
-            delete require.cache[require.resolve(path)];
-
-            let command = require(path);
-
-            command = new command;
-
-            command.filepath = path;
-
-            this.commands.push(command.data.toJSON());
-
-            this.client.commands.interaction.set(command.data.name, command);
-        })
-
-        return this.#redeployCommands()
-    }
-
-    loadAllContextMenuCommands(path, logging = false) {
-        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'));
-
-        for (const file of commandFiles) {
-            try {
-                let filepath = `${require("path").resolve(path)}/${file}`
-
-                let command = require(filepath);
-
-                command = new command;
-
-                command.filepath = filepath;
-
-                this.commands.push(command.data.toJSON());
-
-                this.client.commands.contextMenu.set(command.data.name, command);
-            }
-            catch (error) {
-                console.error(logStyle(`Couldn't load ${file} because of <${error.message}>!`, "text", "red"));
-            }
-        }
-
-        this.#deployCommands("context menu commands", logging);
-    }
-
-    reloadAllContextMenuCommands() {
-        let commands = this.client.commands.contextMenu.map(command => command.filepath);
-
-        this.commands = [];
-
-        this.client.commands.contextMenu.sweep(() => true);
-
-        commands.map(path => {
-            delete require.cache[require.resolve(path)];
-
-            let command = require(path);
-
-            command = new command;
-
-            command.filepath = path;
-
-            this.commands.push(command.data.toJSON());
-
-            this.client.commands.contextMenu.set(command.data.name, command);
-        })
-
-        return this.#redeployCommands()
-    }
-
-    loadAllMessageCommands(path, logging = false) {
-        const commandFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'));
-
-        for (const file of commandFiles) {
-            try {
-                let filepath = `${require("path").resolve(path)}/${file}`
-
-                let command = require(filepath);
-
-                command = new command;
-
-                command.filepath = filepath;
-
-                command.aliases.forEach((alias) => {
-                    if (this.client.commands.message.has(alias)) throw new Error('Cannot have duplicated aliases.');
-
-                    this.client.commands.message.set(alias, command);
-                });
-            }
-            catch (error) {
-                console.error(logStyle(`Couldn't load ${file} because of <${error.message}>!`, "text", "red"));
-            }
-        }
-    }
-
-    reloadAllMessageCommands() {
-        let commands = this.client.commands.message.map(command => command.filepath);
-
-        this.commands = [];
-
-        this.client.commands.message.sweep(() => true);
-
-        commands.map(path => {
-            delete require.cache[require.resolve(path)];
-
-            let command = require(path);
-
-            command = new command;
-
-            command.filepath = path;
-
-            this.client.commands.message.set(command.id, command);
-        })
-
-        return this.#redeployCommands()
-    }
-
-    #deployCommands(type, logging = false) {
-        this.client.once('ready', client => {
-            const rest = new REST({ version: GatewayVersion }).setToken(client.token);
-
-            (async () => {
-                try {
-                    if (client.settings.global == true) {
-                        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} in ${(await client.guilds.fetch()).size} server(s) globally.`, 'text', 'purple'));
-                        rest.put(Routes.applicationCommands(client.user.id), {
-                            body: this.commands
-                        })
-                    }
-                    else {
-                        if (logging || this.client.settings.logging) console.info(logStyle(`Loaded ${type} locally.`, 'text', 'purple'));
-                        rest.put(Routes.applicationGuildCommands(client.user.id, client.settings.guildId), {
-                            body: this.commands
-                        })
-                    }
-                }
-                catch (e) {
-                    throw new Error(e)
-                }
-            })();
-        })
-    }
-
-    #redeployCommands() {
-        const rest = new REST({ version: GatewayVersion }).setToken(this.client.token);
-
-        (async () => {
-            try {
-                if (this.client.settings.global == true) {
-                    rest.put(Routes.applicationCommands(this.client.user.id), {
-                        body: this.commands
-                    })
-                }
-                else {
-                    rest.put(Routes.applicationGuildCommands(this.client.user.id, this.client.settings.guildId), {
-                        body: this.commands
-                    })
-                }
-            }
-            catch (e) {
-                throw new Error(e)
-            }
-        })();
-
-        return this.commands;
-    }
-}
-
-module.exports = Loader;