xernerx 2.4.4 → 2.6.0

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,89 +1,55 @@
 const Discord = require('discord.js');
 const { s } = require('@sapphire/shapeshift');
-const { color, config } = require('./data/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,
-            logging: s.array(s.string).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/ContextMenuCommand.js

@@ -57,9 +57,11 @@ class ContextMenuCommand {
     }
 
     types(str) {
-        if (String(str)?.toLowerCase() == "message") str = 3
-        if (String(str)?.toLowerCase() == "user") str = 2
-        return str
+        if (String(str)?.toLowerCase() == "message") str = 3;
+
+        if (String(str)?.toLowerCase() == "user") str = 2;
+
+        return str;
     }
 }
 

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

@@ -1,8 +1,9 @@
 const { Event } = require('../commands/Event.js');
-const { interactionArgs } = require('./../data/Arguments.js');
+const { interactionArgs } = require('./../utils/Arguments.js');
 const { InteractionType } = require('discord.js')
-const commandValidation = require('./../data/CommandValidation.js');
-const { interactionUtil } = require('./../data/Util.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

@@ -1,7 +1,8 @@
 const { Event } = require('../commands/Event.js');
-const { messageArgs } = require("./../data/Arguments.js");
-const commandValidation = require('./../data/CommandValidation.js');
-const { messageUtil } = require('../data/Util.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

@@ -1,7 +1,8 @@
 const { Event } = require('../commands/Event.js');
-const { messageArgs } = require("./../data/Arguments.js");
-const commandValidation = require('./../data/CommandValidation.js');
-const { messageUtil } = require('../data/Util.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

@@ -13,9 +13,9 @@ class BuildInReadyOnceEvent extends Event {
     }
 
     async run(client) {
-        if (client.logging) console.log(logStyle(`${client.user.tag} is online in ${(await client.guilds.fetch()).size} server(s).`, "text", "green"))
+        if (client.settings.logging) console.info(logStyle(`${client.user.tag} is online in ${(await client.guilds.fetch()).size} servers.`, "text", "cyan"));
 
-        if (client.settings.logging) {
+        if (Array.isArray(client.settings.logging)) {
             let loaded = [];
 
             for (const [type, commands] of Object.entries(client.commands)) {
@@ -29,15 +29,30 @@ class BuildInReadyOnceEvent extends Event {
                     if (!loaded.includes(command)) loaded.push(command);
                 }
             }
+
             for (const [id, event] of [...client.events]) {
-                event.runType = 'event'
+                event.runType = 'event';
+
+                loaded.push(event);
+            }
+
+            for (const [id, inhibitor] of [...client.inhibitors]) {
+                inhibitor.runType = 'inhibitor';
 
-                loaded.push(event)
+                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;
+        }
     }
+
 };
 
 module.exports = BuildInReadyOnceEvent;

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'));
+    }
+}