xernerx 2.0.7 → 2.1.2

package/main.js

@@ -1,36 +1,36 @@
-const { Client } = require('./models/Client.js'),
-    { CommandHandler } = require('./models/handlers/CommandHandler.js'),
-    { EventHandler } = require('./models/handlers/EventHandler.js'),
-    { MessageCommand } = require('./models/commands/MessageCommand.js'),
-    { InteractionCommand } = require('./models/commands/InteractionCommand.js'),
-    { Event } = require('./models/commands/Event.js'),
-    { LanguageHandler } = require('./models/handlers/LanguageHandler.js'),
-    { ContextMenuCommand } = require('./models/commands/ContextMenuCommand.js'),
-    pkg = require('./package.json'),
-    Dumfunctions = require('dumfunctions'),
-    Discord = require('discord.js');
-
-module.exports = {
-    // Client
-    Client,
-
-    // Handlers
-    CommandHandler,
-    EventHandler,
-    LanguageHandler,
-
-    // Commands
-    MessageCommand,
-    InteractionCommand,
-    ContextMenuCommand,
-
-    // Events
-    Event,
-
-    // Discord
-    Discord,
-    functions: Dumfunctions,
-
-    // Details
-    version: pkg.version,
+const { Client } = require('./models/Client.js'),
+    { CommandHandler } = require('./models/handlers/CommandHandler.js'),
+    { EventHandler } = require('./models/handlers/EventHandler.js'),
+    { MessageCommand } = require('./models/commands/MessageCommand.js'),
+    { InteractionCommand } = require('./models/commands/InteractionCommand.js'),
+    { Event } = require('./models/commands/Event.js'),
+    { LanguageHandler } = require('./models/handlers/LanguageHandler.js'),
+    { ContextMenuCommand } = require('./models/commands/ContextMenuCommand.js'),
+    pkg = require('./package.json'),
+    Dumfunctions = require('dumfunctions'),
+    Discord = require('discord.js');
+
+module.exports = {
+    // Client
+    Client,
+
+    // Handlers
+    CommandHandler,
+    EventHandler,
+    LanguageHandler,
+
+    // Commands
+    MessageCommand,
+    InteractionCommand,
+    ContextMenuCommand,
+
+    // Events
+    Event,
+
+    // Discord
+    Discord,
+    functions: Dumfunctions,
+
+    // Details
+    version: pkg.version,
 } 

package/models/Client.js

@@ -7,7 +7,7 @@ const { LanguageHandler } = require('./handlers/LanguageHandler.js');
 
 /**
  * @param {string} guildId - Test guild ID. 
- * @param {boolean} global - Whether the bot shoumd be globally or locally loaded. 
+ * @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. 
@@ -30,7 +30,6 @@ class Client extends Discord.Client {
             defaultCooldown: s.number.optional,
             logging: s.boolean.optional,
             cacheTime: s.number.optional,
-            dummi: s.boolean.optional,
             userPermissions: s.array(s.string).optional,
             clientPermissions: s.array(s.string).optional
         }).parse(options)

package/models/commands/MessageCommand.js

@@ -34,7 +34,7 @@ class MessageCommand {
 
         this.id = id;
 
-        this.aliases = [...(options.aliases ? options.aliases : []), options.name];
+        this.aliases = [options.name, ...(options.aliases ? options.aliases : [])];
 
         this.type = options.type;
 

package/models/data/Arguments.js

@@ -0,0 +1,108 @@
+class Arguments {
+    /**
+     * 
+     * @param {object} interaction - Interaction event.
+     * @returns argument options without having to do the whole builders way.
+     */
+    interactionArgs(interaction) {
+        let group, sub, options = {};
+
+        if (interaction?.options?._group) group = interaction.options._group;
+
+        if (interaction?.options?._subcommand) sub = interaction.options._subcommand;
+
+        if (interaction?.options?._hoistedOptions) {
+            for (const option of interaction.options._hoistedOptions) {
+                options[option.name] = option.channel || option.user || option.role || option.value;
+            }
+        }
+
+        return { group, sub, options };
+    }
+
+    /**
+     * 
+     * @param {object} message - Message Object. 
+     * @param {object} command - Command Class.
+     * @returns argument options without having to make them yourself.
+     */
+    async messageArgs({ message: message, command: command }) {
+        let args = {}, separator = command.separator || ' ', i = 0;
+
+        if (!command.args) return;
+
+        for (const argument of command.args) {
+
+            let content = message.content.replace(new RegExp(`${separator}${separator}+`, "g"), separator).split(separator).slice(i + 1);
+
+            if (content.join(separator) != '') {
+
+                if (argument?.content?.includes(content[0])) {
+                    args[argument.name] = content[0];
+                }
+
+                else if (argument.type == 'string') {
+                    args[argument.name] = content[0];
+                }
+
+                else if (argument.type == 'number') {
+                    args[argument.name] = parseInt(content[0]);
+                }
+
+                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 }
+                    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 }
+                    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 }
+                    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 }
+                    args[argument.name] = channel;
+                }
+
+                else if (argument.type == 'rest') {
+                    args[argument.name] = content.join(separator);
+                    break;
+                }
+
+                else if (argument.prompt) {
+                    if (argument.prompt.reply) return message.reply(argument.prompt.reply);
+                    else if (argument.prompt.send) return message.channel.send(argument.prompt.send);
+                }
+
+                else args[argument.name] = undefined;
+
+                i++
+            }
+
+            else args[argument.name] = undefined;
+        }
+
+        return args;
+    }
+}
+
+args = new Arguments()
+
+module.exports = {
+    interactionArgs: args.interactionArgs,
+    messageArgs: args.messageArgs
+}

package/models/data/CommandValidation.js

@@ -3,94 +3,98 @@ const { toPascalCase } = require('dumfunctions');
 
 const Cooldown = {};
 
-module.exports = function commandValidation(event, command, res = false) {
-    function emit(reason, extra) {
-        return event.client.emit('commandBlocked', event, reason, extra);
-    }
-
-    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]) {
-        res = true;
-        return emit("command on cooldown", (Cooldown[(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));
-
-        setTimeout(() => {
-            delete Cooldown[(event.user || event.author).id]
-        }, command.cooldown || event?.client?.settings?.defaultCooldown || 0);
-    }
+class CommandValidation {
+    commandValidation(event, command, res = false) {
+        function emit(reason, extra) {
+            return event.client.emit('commandBlocked', event, reason, extra);
+        }
 
-    if (command?.owner && event?.client?.settings?.ownerId != undefined && !event?.client?.settings?.ownerId?.includes((event.user || event.author).id)) {
-        res = true;
-        return emit("missing ownership", event?.client?.settings?.ownerId)
-    }
+        if ((command?.ignoreOwner || event?.client?.settings?.ignoreOwner) && event?.client?.settings?.ownerId?.includes((event.user || event.author).id)) return res;
 
-    if (command?.admin && event?.member?.permissions?.has(Discord.PermissionFlagsBits.Administrator) == false) {
-        res = true;
-        return emit("missing admin permission", "Administrator")
-    }
+        if (Cooldown[(event.user || event.author).id]) {
+            res = true;
+            return emit("command on cooldown", (Cooldown[(event.user || event.author).id] - (event.editedTimestamp || event.createdTimestamp)));
+        }
 
-    if (command?.channel == "guild" && event?.channel?.type != "GUILD_TEXT") {
-        res = true
-        return emit("not a guild channel");
-    }
+        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 (command?.channel == "dm" && event?.type != null) {
-        res = true;
-        return emit("not a dm channel");
-    }
+            setTimeout(() => {
+                delete Cooldown[(event.user || event.author).id]
+            }, command.cooldown || event?.client?.settings?.defaultCooldown || 0);
+        }
 
-    if (command?.inVoice && !event?.member?.voice?.channelId) {
-        res = true;
-        return emit("not a in a voice channel");
-    }
+        if (command?.owner && event?.client?.settings?.ownerId != undefined && !event?.client?.settings?.ownerId?.includes((event.user || event.author).id)) {
+            res = true;
+            return emit("missing ownership", event?.client?.settings?.ownerId)
+        }
 
-    if (event?.guild && command?.userPermissions?.length >= 1 || event?.client?.settings?.userPermissions?.length >= 1) {
-        let missingPerms = [];
+        if (command?.admin && event?.member?.permissions?.has(Discord.PermissionFlagsBits.Administrator) == false) {
+            res = true;
+            return emit("missing admin permission", "Administrator")
+        }
 
-        for (const permission of command.userPermissions) {
-            if (!event?.member?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+        if (command?.channel == "guild" && event?.channel?.type != "GUILD_TEXT") {
+            res = true
+            return emit("not a guild channel");
         }
 
-        for (const permission of event?.client?.settings?.userPermissions) {
-            if (!event?.member?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+        if (command?.channel == "dm" && event?.type != null) {
+            res = true;
+            return emit("not a dm channel");
         }
 
-        if (missingPerms.length >= 1) {
+        if (command?.inVoice && !event?.member?.voice?.channelId) {
             res = true;
-            return emit("missing user permissions", missingPerms);
+            return emit("not a in a voice channel");
         }
-    }
 
-    if (event?.guild && command?.clientPermissions.length >= 1 || event.client.settings.clientPermissions.length >= 1) {
-        let missingPerms = [];
+        if (event?.guild && command?.userPermissions?.length >= 1 || event?.client?.settings?.userPermissions?.length >= 1) {
+            let missingPerms = [];
+
+            for (const permission of command.userPermissions) {
+                if (!event?.member?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+            }
+
+            for (const permission of event?.client?.settings?.userPermissions) {
+                if (!event?.member?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+            }
 
-        for (const permission of command?.clientPermissions) {
-            if (!event?.guild?.members?.me?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+            if (missingPerms.length >= 1) {
+                res = true;
+                return emit("missing user permissions", missingPerms);
+            }
         }
 
-        for (const permission of event?.client?.settings?.clientPermissions) {
-            if (!event?.guild?.members?.me?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+        if (event?.guild && command?.clientPermissions.length >= 1 || event.client.settings.clientPermissions.length >= 1) {
+            let missingPerms = [];
+
+            for (const permission of command?.clientPermissions) {
+                if (!event?.guild?.members?.me?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+            }
+
+            for (const permission of event?.client?.settings?.clientPermissions) {
+                if (!event?.guild?.members?.me?.permissions?.has(Discord.PermissionFlagsBits[toPascalCase(permission)])) missingPerms.push(toPascalCase(permission));
+            }
+
+            if (missingPerms.length >= 1) {
+                res = true;
+                return emit("missing client permissions", missingPerms);
+            }
         }
 
-        if (missingPerms.length >= 1) {
+        if (command?.guilds?.length >= 1 && !command?.guilds?.includes(event.guild)) {
             res = true;
-            return emit("missing client permissions", missingPerms);
+            return emit('not in a specified guild', command.guilds);
         }
-    }
 
-    if (command?.guilds?.length >= 1 && !command?.guilds?.includes(event.guild)) {
-        res = true;
-        return emit('not in a specified guild', command.guilds);
-    }
+        if (command?.channels?.length >= 1 && !command?.channels?.includes(event.channel.id)) {
+            res = true;
+            return emit('not in a specified channel', command.channels);
+        }
 
-    if (command?.channels?.length >= 1 && !command?.channels?.includes(event.channel.id)) {
-        res = true;
-        return emit('not in a specified channel', command.channels);
+        return res;
     }
+}
 
-    return res;
-}
+module.exports = new CommandValidation().commandValidation;

package/models/data/Functions.js

@@ -39,176 +39,6 @@ class Functions {
 
         return client.config;
     }
-
-    /**
-     * 
-     * @param {object} interaction - Interaction event.
-     * @returns argument options without having to do the whole builders way.
-     */
-    interactionArgs(interaction) {
-        let group, sub, options = {};
-
-        if (interaction?.options?._group) group = interaction.options._group;
-
-        if (interaction?.options?._subcommand) sub = interaction.options._subcommand;
-
-        if (interaction?.options?._hoistedOptions) {
-            for (const option of interaction.options._hoistedOptions) {
-                options[option.name] = option.channel || option.user || option.role || option.value;
-            }
-        }
-
-        return { group, sub, options };
-    }
-
-    /**
-     * 
-     * @param {object} message - Message Object. 
-     * @param {object} command - Command Class.
-     * @returns argument options without having to make them yourself.
-     */
-    async messageArgs({ message: message, command: command }) {
-        let args = {}, separator = command.separator || ' ', i = 0;
-
-        if (!command.args) return;
-
-        for (const argument of command.args) {
-
-            let content = message.content.replace(new RegExp(`${separator}${separator}+`, "g"), separator).split(separator).slice(i + 1);
-
-            if (content.join(separator) != '') {
-
-                if (argument?.content?.includes(content[0])) {
-                    args[argument.name] = content[0];
-                }
-
-                else if (argument.type == 'string') {
-                    args[argument.name] = content[0];
-                }
-
-                else if (argument.type == 'number') {
-                    args[argument.name] = parseInt(content[0]);
-                }
-
-                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 }
-                    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 }
-                    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 }
-                    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 }
-                    args[argument.name] = channel;
-                }
-
-                else if (argument.type == 'rest') {
-                    args[argument.name] = content.join(separator);
-                    break;
-                }
-
-                else if (argument.prompt) {
-                    if (argument.prompt.reply) return message.reply(argument.prompt.reply);
-                    else if (argument.prompt.send) return message.channel.send(argument.prompt.send);
-                }
-
-                else args[argument.name] = undefined;
-
-                i++
-            }
-
-            else args[argument.name] = undefined;
-        }
-
-        return args;
-    }
-
-    async messageEdit(message, type) {
-        setTimeout(() => {
-            if (message.client.messages[message.id] === null || message.client.messages[message.id]) delete message.client.messages[message.id];
-
-            if (message.channel.messages.cache.has(message.id)) message.channel.messages.cache.delete(message.id);
-        }, message.client.settings.cacheTime);
-
-        message.util = {};
-
-        if (type == "create") {
-            message.client.messages[message.id] = null;
-
-            message.util.send = async (e) => {
-                const msg = await message.channel.send(e);
-
-                message.client.messages[message.id] = msg.id;
-
-                return msg;
-            }
-
-            message.util.reply = async (e) => {
-                const msg = await message.reply(e);
-
-                message.client.messages[message.id] = msg.id;
-
-                return msg;
-            }
-
-            return;
-        }
-
-        if (type == 'edit') {
-            if (message.client.messages[message.id] === null) {
-                message.util.send = async (e) => {
-                    const msg = await message.channel.send(e);
-
-                    message.client.messages[message.id] = msg.id;
-
-                    return msg;
-                }
-
-                message.util.reply = async (e) => {
-                    const msg = await message.reply(e);
-
-                    message.client.messages[message.id] = msg.id;
-
-                    return msg;
-                }
-
-                return;
-            }
-
-            else if (message.client.messages[message.id] !== null) {
-                const msg = await message.channel.messages.fetch(message.client.messages[message.id]);
-
-                message.util.send = async (e) => {
-                    return await msg.edit(e);
-                }
-
-                message.util.reply = async (e) => {
-                    return await msg.edit(e);
-                }
-
-                return;
-            }
-        }
-
-        else return;
-    }
 }
 
 module.exports = new Functions();

package/models/data/Util.js

@@ -0,0 +1,213 @@
+const { EmbedBuilder, ActionRowBuilder, SelectMenuBuilder, Embed, ButtonBuilder, ButtonStyle } = require('discord.js');
+const opts = require('./options.json');
+
+function reply(interaction, text) {
+    return (interaction.replied || interaction.deferred) ? interaction.editReply(text) : interaction.reply(text);
+}
+
+function selectMenuPaginator(interaction, embeds, options = {}) {
+    if (!embeds) return interaction.client.emit('error', interaction, "no embeds");
+
+    if (!Array.isArray(embeds)) return interaction.client.emit('error', interaction, "no array of embeds")
+
+    if (!options.index) {
+        options.index = new EmbedBuilder()
+            .setTitle(`${embeds.length} pages`)
+
+        embeds.map((embed, i = 0) => options.index.addFields([{ name: embed?.data?.title || embed?.data?.author?.name || "No name", value: embed?.data?.description || `Page ${i + 1}` }]))
+    }
+
+    if (!options.row) {
+        options.row = new ActionRowBuilder();
+
+        if (!options.id) options.id = `${interaction.id}-menu`;
+
+        options.comp = new SelectMenuBuilder()
+            .setCustomId(options.id)
+            .setMaxValues(1)
+            .setMinValues(1)
+            .setPlaceholder('Select a page.')
+            .addOptions({ label: 'Index', description: 'Index Page', value: 'index' })
+
+        embeds.map((embed, i = 0) => options.comp.addOptions({ label: embed?.data?.title || embed?.data?.author?.name, description: embed?.data?.description?.slice(0, 100) || `Page ${i + 1}`, value: opts[embeds.indexOf(embed)] }))
+
+        options.row.addComponents(options.comp);
+    }
+
+    if (!options.id) options.id = options.row.components[0].data.custom_id;
+
+    (async () => {
+        let embed = options.index;
+
+        let m = options.send ? await interaction.channel.send({ embeds: [embed], components: [options.row] }) : await reply(interaction, { embeds: [embed], components: [options.row] })
+
+        interaction.channel.createMessageComponentCollector({ filter: options.filter, time: options.time || 300000 })
+
+            .on('collect', async (a) => {
+                if (a.customId != options.id) return;
+
+                let chosen = a.values[0];
+
+                if (chosen === options.row.components[0]?.options[0]?.data?.value) embed = options.index;
+
+                else embed = embeds[opts.indexOf(chosen)];
+
+                a.update({ embeds: [embed] });
+            })
+
+            .on('end', async () => {
+                if (interaction.editReply) interaction.editReply({ components: [] });
+
+                if (interaction.edit) await m.edit({ components: [] });
+            })
+    })();
+}
+
+function buttonPaginator(interaction, embeds, options = {}) {
+    if (!options.buttons) options.buttons = ["⏪", "◀️", "⏹️", "▶️", "⏩"];
+
+    if (options.buttons.length <= 4 || options.buttons.length > 5) throw new Error('Must specify 5 emotes.')
+
+    options.row = new ActionRowBuilder()
+
+    for (const button of options.buttons) {
+        options.row
+            .addComponents(
+                new ButtonBuilder()
+                    .setCustomId(`${interaction.id}-${opts[options.buttons.indexOf(button)]}`)
+                    .setStyle(ButtonStyle[options.style || 'Primary'])
+                    .setEmoji(button)
+            )
+    }
+
+    (async () => {
+        let embed = embeds[options.index || 0];
+
+        let m = options.send ? await interaction.channel.send({ embeds: [embed], components: [options.row] }) : await reply(interaction, { embeds: [embed], components: [options.row] });
+
+        interaction.channel.createMessageComponentCollector({ filter: options.filter, time: options.time || 300000 })
+
+            .on('collect', async (a) => {
+                if (a.customId == `${interaction.id}-one`) {
+                    embed = embeds[0];
+                    a.update({ embeds: [embed] });
+                }
+
+                if (a.customId == `${interaction.id}-two`) {
+                    embed = embeds[embeds.indexOf(embed) >= 1 ? embeds.indexOf(embed) - 1 : 0];
+                    a.update({ embeds: [embed] });
+                }
+
+                if (a.customId == `${interaction.id}-three`) {
+                    a.update({ components: [] });
+                }
+
+                if (a.customId == `${interaction.id}-four`) {
+                    embed = embeds[embeds.indexOf(embed) < embeds.length - 1 ? embeds.indexOf(embed) + 1 : embeds.length - 1];
+                    a.update({ embeds: [embed] });
+                }
+
+                if (a.customId == `${interaction.id}-five`) {
+                    embed = embeds[embeds.length - 1];
+                    a.update({ embeds: [embed] });
+                }
+            })
+
+            .on('end', async () => {
+                if (interaction.editReply) interaction.editReply({ components: [] });
+
+                if (interaction.edit) await m.edit({ components: [] });
+            })
+    })();
+}
+
+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.channel.messages.cache.has(message.id)) message.channel.messages.cache.delete(message.id);
+        }, message.client.settings.cacheTime);
+
+        message.util = {};
+
+        message.util.selectMenuPaginator = (embeds, options) => selectMenuPaginator(message, embeds, options);
+
+        message.util.buttonPaginator = (embeds, options) => buttonPaginator(message, embeds, options);
+
+        if (type == "create") {
+            message.client.messages[message.id] = null;
+
+            message.util.send = async (e) => {
+                const msg = await message.channel.send(e);
+
+                message.client.messages[message.id] = msg.id;
+
+                return msg;
+            }
+
+            message.util.reply = async (e) => {
+                const msg = await message.reply(e);
+
+                message.client.messages[message.id] = msg.id;
+
+                return msg;
+            }
+
+            return;
+        }
+
+        if (type == 'edit') {
+            if (message.client.messages[message.id] === null) {
+                message.util.send = async (e) => {
+                    const msg = await message.channel.send(e);
+
+                    message.client.messages[message.id] = msg.id;
+
+                    return msg;
+                }
+
+                message.util.reply = async (e) => {
+                    const msg = await message.reply(e);
+
+                    message.client.messages[message.id] = msg.id;
+
+                    return msg;
+                }
+
+                return;
+            }
+
+            else if (message.client.messages[message.id] !== null) {
+                const msg = await message.channel.messages.fetch(message.client.messages[message.id]);
+
+                message.util.send = async (e) => {
+                    return await msg.edit(e);
+                }
+
+                message.util.reply = async (e) => {
+                    return await msg.edit(e);
+                }
+
+                return;
+            }
+        }
+    }
+
+    interactionUtil(interaction) {
+        interaction.util = {}
+
+        interaction.util.reply = (text) => reply(interaction, text);
+
+        interaction.util.selectMenuPaginator = (embeds, options) => selectMenuPaginator(interaction, embeds, options);
+
+        interaction.util.buttonPaginator = (embeds, options) => buttonPaginator(interaction, embeds, options);
+    }
+}
+
+u = new Util;
+
+module.exports = {
+    messageUtil: u.messageUtil,
+    interactionUtil: u.interactionUtil
+};

package/models/data/options.json

@@ -0,0 +1,27 @@
+[
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten",
+  "eleven",
+  "twelve",
+  "thirteen",
+  "fourteen",
+  "fifteen",
+  "sixteen",
+  "seventeen",
+  "eighteen",
+  "nineteen",
+  "twenty",
+  "twentyone",
+  "twentytwo",
+  "twentythree",
+  "twentyfour",
+  "twentyfive"
+]

package/models/events/interactionCreate.js

@@ -1,7 +1,8 @@
 const { Event } = require('../commands/Event.js');
-const { interactionArgs } = require('./../data/Functions.js');
+const { interactionArgs } = require('./../data/Arguments.js');
 const { InteractionType } = require('discord.js')
 const commandValidation = require('./../data/CommandValidation.js');
+const { interactionUtil } = require('./../data/Util.js');
 /**
  * @returns interaction command executor.
  */
@@ -15,6 +16,8 @@ class BuildInInteractionEvent extends Event {
     }
 
     async run(interaction) {
+        await interactionUtil(interaction)
+
         if (interaction.type == InteractionType.ApplicationCommand) {
             if (interaction.client.interactionCommands.has(interaction.commandName)) {
                 let command = interaction.client.interactionCommands.get(interaction.commandName);
@@ -29,13 +32,6 @@ class BuildInInteractionEvent extends Event {
 
                 if (commandValidation(interaction, command)) return;
 
-                interaction.util = {}
-
-                interaction.util.reply = (text) => {
-                    if (interaction.replied || interaction.deferred) return interaction.editReply(text);
-                    else return interaction.reply(text);
-                }
-
                 try {
                     await command.exec(interaction, { group: group, subcommand: subcommand, args: args });
 

package/models/events/messageCreate.js

@@ -1,6 +1,7 @@
 const { Event } = require('../commands/Event.js');
-const { messageArgs, messageEdit } = require("./../data/Functions.js");
+const { messageArgs } = require("./../data/Arguments.js");
 const commandValidation = require('./../data/CommandValidation.js');
+const { messageUtil } = require('../data/Util.js');
 
 /**
  * @returns message command executor.
@@ -16,8 +17,9 @@ class BuildInMessageEvent extends Event {
 
     async run(message) {
         if (!message.author.bot) {
+            if (message?.client?.settings?.prefix?.length <= 0) return;
 
-            await messageEdit(message, "create");
+            await messageUtil(message, "create");
 
             for (const prefix of message.client.settings.prefix) {
                 if (!message.content.startsWith(prefix)) continue;

package/models/events/messageUpdate.js

@@ -1,6 +1,7 @@
 const { Event } = require('../commands/Event.js');
-const { messageArgs, messageEdit } = require("./../data/Functions.js");
+const { messageArgs } = require("./../data/Arguments.js");
 const commandValidation = require('./../data/CommandValidation.js');
+const { messageUtil } = require('../data/Util.js');
 
 /**
  * @returns message command executor.
@@ -15,19 +16,20 @@ class BuildInMessageUpdateEvent extends Event {
     }
 
     async run(oldMessage, newMessage) {
+        if (newMessage?.client?.settings?.prefix?.length <= 0) return;
 
-        await messageEdit(newMessage, "edit");
+        await messageUtil(newMessage, "edit");
 
         if (!oldMessage.author.bot && !newMessage.author.bot) {
 
-            if (!newMessage.client.messages[newMessage.id] == undefined) return;
+            if (!newMessage.client.messages[newMessage.id] === undefined) return;
 
             for (const prefix of newMessage.client.settings.prefix) {
                 if (!newMessage.content.startsWith(prefix)) continue;
 
                 let command = newMessage.content.replace(prefix, "").split(/ +/).shift().toLowerCase();
 
-                if (!newMessage.client.messageCommands.has(command) || command == '') return;
+                if (!newMessage.client.messageCommands.has(command) || command === '') return;
 
                 command = newMessage.client.messageCommands.get(command);
 

package/package.json

@@ -1,28 +1,28 @@
-{
-  "name": "xernerx",
-  "version": "2.0.7",
-  "description": "A bot framework for discord.js. [BETA]",
-  "main": "main.js",
-  "scripts": {
-    "test": "echo Setup a bot then start the bot."
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/TheDummi/xernerx.git"
-  },
-  "author": "Dummi",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/TheDummi/xernerx/issues"
-  },
-  "homepage": "https://github.com/TheDummi/xernerx#readme",
-  "dependencies": {
-    "@discordjs/rest": "1.0.1",
-    "@sapphire/shapeshift": "3.5.1",
-    "discord-api-types": "^0.37.0",
-    "discord.js": "^14.1.2",
-    "dumfunctions": "^1.0.6",
-    "i18next": "^21.8.16"
-  },
-  "packageManager": "npm@8.5.5"
-}
+{
+  "name": "xernerx",
+  "version": "2.1.2",
+  "description": "A bot framework for discord.js. [BETA]",
+  "main": "main.js",
+  "scripts": {
+    "test": "echo Setup a bot then start the bot."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TheDummi/xernerx.git"
+  },
+  "author": "Dummi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/TheDummi/xernerx/issues"
+  },
+  "homepage": "https://github.com/TheDummi/xernerx#readme",
+  "dependencies": {
+    "@discordjs/rest": "1.0.1",
+    "@sapphire/shapeshift": "3.5.1",
+    "discord-api-types": "^0.37.0",
+    "discord.js": "^14.1.2",
+    "dumfunctions": "^1.0.7",
+    "i18next": "^21.8.16"
+  },
+  "packageManager": "npm@8.5.5"
+}