xernerx 2.4.4 → 2.6.0

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/{data → utils}/Arguments.js

@@ -1,4 +1,4 @@
-class Arguments {
+module.exports = new class Arguments {
     /**
      * 
      * @param {object} interaction - Interaction event.
@@ -27,16 +27,26 @@ 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, "");
+
+                    args.flags[flag.name] = true;
+                }
+            }
 
-            let content = message.content.replace(new RegExp(`${separator}${separator}+`, "g"), separator).split(separator).slice(i + 1);
+            if (!args.flags[flag.name]) args.flags[flag.name] = false;
+        })
 
-            if (content.join(separator) != '') {
+        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 @@ 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,21 +107,14 @@ 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;
     }
-}
-
-args = new Arguments()
-
-module.exports = {
-    interactionArgs: args.interactionArgs,
-    messageArgs: args.messageArgs
 }

package/models/{data → utils}/CommandValidation.js

@@ -1,9 +1,7 @@
 const Discord = require('discord.js');
 const { toPascalCase } = require('dumfunctions');
 
-const Cooldown = {};
-
-class CommandValidation {
+module.exports = new class CommandValidation {
     commandValidation(event, command, res = false) {
         function emit(reason, extra) {
             return event.client.emit('commandBlocked', event, reason, extra);
@@ -11,16 +9,16 @@ 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);
         }
 
@@ -95,6 +93,4 @@ class CommandValidation {
 
         return res;
     }
-}
-
-module.exports = new CommandValidation().commandValidation;
+}

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

@@ -0,0 +1,259 @@
+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);
+}
+
+/**
+ * @param {object} Functions - Build in functions of the bot hidden away in the handlers/setters.
+ */
+module.exports = new class Functions {
+    /**
+     * 
+     * @param {object} client - Client object.
+     * @param {object} options - Client options.   
+     * @returns an object of default colors and custom colors to be imported anywhere without having to import them.
+     */
+    color({ client: client, options: options }) {
+        client.color = { FLAGS: colors }
+
+        if (options.color) {
+            for (const [name, color] of Object.entries(options.color)) {
+                client.color[name] = color;
+            }
+        }
+
+        return client.color;
+    }
+
+    /**
+     * 
+     * @param {object} client - Client object.
+     * @param {object} options - Client options. 
+     * @returns custom config settings for the bot.
+     */
+    config({ client: client, options: options }) {
+        client.config = {}
+
+        if (options.config) {
+            for (const [key, value] of Object.entries(options.config)) {
+                client.config[key] = value;
+            }
+        }
+
+        return client.config;
+    }
+
+    reply(interaction, text) {
+        return (interaction.replied || interaction.deferred) ? interaction.editReply(text) : interaction.reply(text);
+    }
+
+    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: [] });
+                })
+        })();
+    }
+
+    commandName(interaction, cmd) {
+        if (cmd) {
+            let cmds = [];
+
+            for (const commands of Object.values(interaction.client.commands)) {
+                let commandInfo = {};
+
+                if (commands.has(cmd)) {
+                    const command = commands.get(cmd);
+
+                    if (command?.data?.options?.length > 0) {
+                        command?.data?.options?.map(option => {
+                            if (!option?.type) {
+                                if (option?.options?.length > 0) {
+                                    option?.options?.map(opt => {
+                                        if (!opt.type) {
+                                            commandInfo = {
+                                                name: command?.data?.name + " " + option?.name + " " + opt?.name,
+                                                description: opt.description,
+                                                category: command.category
+                                            }
+                                        }
+
+                                        else {
+                                            commandInfo = {
+                                                name: command?.data?.name + " " + option?.name,
+                                                description: option?.description,
+                                                category: command.category
+                                            }
+                                        }
+                                    })
+                                }
+
+                                else {
+                                    commandInfo = {
+                                        name: command?.data?.name + " " + option?.name,
+                                        description: option?.description,
+                                        category: command.category
+                                    }
+                                }
+                            }
+
+                            else {
+                                commandInfo = {
+                                    name: command?.data?.name || command?.name || command?.id,
+                                    description: command?.data?.description || command?.description,
+                                    category: command.category
+                                }
+                            }
+                        })
+                    }
+
+                    else {
+                        commandInfo = {
+                            name: command?.data?.name || command?.name || command?.id,
+                            description: command?.data?.description || command?.description,
+                            category: command.category
+                        }
+                    }
+
+                    cmds.push(commandInfo);
+                }
+
+            }
+            return cmds;
+        }
+
+        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 = {}) {
+        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] });
+
+            const collector = 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: [] });
+                        collector.stop();
+                    }
+
+                    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: [] });
+                })
+        })();
+    }
+
+    uptime(interaction, timestamp) {
+        if (!timestamp) timestamp = interaction.client.uptime;
+        let totalSeconds = timestamp / 1000;
+        let years = Math.floor(totalSeconds / 31536000);
+        totalSeconds %= 31536000;
+        let days = Math.floor(totalSeconds / 86400);
+        totalSeconds %= 86400;
+        let hours = Math.floor(totalSeconds / 3600);
+        totalSeconds %= 3600;
+        let minutes = Math.floor(totalSeconds / 60);
+        let seconds = Math.floor(totalSeconds % 60);
+
+        if (years >= 1) return `${years}y ${days}d ${hours}h ${minutes}m`
+        else if (days >= 1) return `${days}d ${hours}h ${minutes}m`;
+        else if (hours >= 1) return `${hours}h ${minutes}m`;
+        else if (minutes >= 1) return `${minutes}m ${seconds}s`;
+        else return `${seconds}s`;
+    }
+}

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

@@ -0,0 +1,96 @@
+const { selectMenuPaginator, buttonPaginator, commandName, uptime, reply } = require('./Functions.js');
+
+module.exports = new class Util {
+    async messageUtil(message, type) {
+        setTimeout(() => {
+            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);
+
+        message.util = {
+            selectMenuPaginator: (embeds, options) => selectMenuPaginator(message, embeds, options),
+            buttonPaginator: (embeds, options) => buttonPaginator(message, embeds, options),
+            commandName: (command) => commandName(message, command),
+            uptime: (timestamp) => uptime(message, timestamp)
+        }
+
+        if (type == "create") {
+            message.client.data.messages[message.id] = null;
+
+            message.util.send = async (e) => {
+                const msg = await message.channel.send(e);
+
+                message.client.data.messages[message.id] = msg.id;
+
+                return msg;
+            }
+
+            message.util.reply = async (e) => {
+                const msg = await message.reply(e);
+
+                message.client.data.messages[message.id] = msg.id;
+
+                return msg;
+            }
+
+            return;
+        }
+
+        if (type == 'edit') {
+            if (message.client.data.messages[message.id] === null) {
+                message.util.send = async (e) => {
+                    const msg = await message.channel.send(e);
+
+                    message.client.data.messages[message.id] = msg.id;
+
+                    return msg;
+                }
+
+                message.util.reply = async (e) => {
+                    const msg = await message.reply(e);
+
+                    message.client.data.messages[message.id] = msg.id;
+
+                    return msg;
+                }
+
+                return;
+            }
+
+            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 {
+                        return await msg.edit(e);
+                    }
+                    catch {
+                        message.channel.send(e);
+                    }
+                }
+
+                message.util.reply = async (e) => {
+                    try {
+                        return await msg.edit(e);
+                    }
+                    catch {
+                        message.reply(e);
+                    }
+                }
+
+                return;
+            }
+        }
+    }
+
+    interactionUtil(interaction) {
+        interaction.util = {
+            reply: (text) => reply(interaction, text),
+            selectMenuPaginator: (embeds, options) => selectMenuPaginator(interaction, embeds, options),
+            buttonPaginator: (embeds, options) => buttonPaginator(interaction, embeds, options),
+            commandName: (command) => commandName(interaction, command),
+            uptime: (timestamp) => uptime(interaction, timestamp)
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xernerx",
-	"version": "2.4.4",
+	"version": "2.6.0",
 	"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"
 	},