xernerx 2.7.4 → 3.0.0

package/models/commands/InteractionCommand.js

@@ -1,142 +0,0 @@
-const { s } = require('@sapphire/shapeshift');
-const { SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandBuilder, SlashCommandBuilder } = require('discord.js');
-const { toTitleCase } = require('dumfunctions');
-
-/**
- * @param {string} name - The name of the command. @required
- * @param {string} description - The brief description of the command. @required
- * @param {string} detailedDescription - The detailed description of the command.
- * @param {boolean} owner - Wether the command can be executed by the bot owner only or not.
- * @param {boolean} admin - Wether the command can be executed by the guild admins only or not.
- * @param {string} channel - Wheter the command can only be executed in a DM, a Guild, or both.
- */
-class InteractionCommand {
-    constructor(id, options = {}) {
-
-        s.object({
-            name: s.string,
-            description: s.string,
-            info: s.string.optional,
-            owner: s.boolean.optional,
-            admin: s.boolean.optional,
-            channel: s.string.optional,
-            category: s.string.optional,
-            cooldown: s.number.optional,
-            ignoreOwner: s.boolean.optional,
-            inVoice: s.boolean.optional,
-            channels: s.array(s.string).optional,
-            guilds: s.array(s.string).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.data = new SlashCommandBuilder()
-            .setName(options.name)
-            .setDescription(options.description)
-
-        if (["args", "subcommands", "groups"].map(x => options[x]?.length).filter(x => x).length > 1) throw new Error("Args, subs, and groups are mutually exclusive");
-
-        if (options?.args?.length > 0) {
-            this.addOptions(this.data, options.args);
-        }
-
-        else if (options?.subs?.length > 0) {
-            this.addSubcommands(this.data, options.subs);
-        }
-
-        else if (options?.groups?.length > 0) {
-            this.addSubcommandGroups(options.groups);
-        }
-
-        this.id = id;
-
-        this.owner = options.owner || false;
-
-        this.admin = options.admin || false;
-
-        this.channel = options.channel || undefined;
-
-        this.category = options.category || undefined;
-
-        this.config = options.config;
-
-        this.cooldown = options.cooldown || 0;
-
-        this.ignoreOwner = options.ignoreOwner || false;
-
-        this.inVoice = options.inVoice || false;
-
-        this.info = options.info || undefined;
-
-        this.channels = options.channels || [];
-
-        this.guilds = options.guilds || [];
-
-        this.userPermissions = options.userPermissions || [];
-
-        this.clientPermissions = options.clientPermissions || [];
-
-        this.defer = {
-            reply: options?.defer?.reply === undefined ? null : options?.defer?.reply,
-            ephemeral: options?.defer?.ephemeral === undefined ? null : options?.defer?.ephemeral
-        }
-    }
-
-    exec(interaction) {
-        /*
-         * Make your custom command here.
-         */
-    }
-
-    addOptions(where, args) {
-        const types = ["boolean", "integer", "number", "string", "user", "role", "channel", "mentionable"];
-
-        for (const argument of args) {
-            if (!types.includes(argument.type.toLowerCase())) throw new Error(`Expected one of ${types.join(', ')}, received ${argument.type} instead.`);
-
-            where[`add${toTitleCase(argument.type, true)}Option`](option => {
-                option
-                    .setName(argument.name)
-                    .setDescription(argument.description)
-                    .setRequired(argument.required || false)
-                if (argument.choices) option.setChoices(...argument?.choices);
-
-                return option;
-            })
-        }
-    }
-
-    addSubcommands(where, subs) {
-        for (const sub of subs) {
-            let subCommand = new SlashCommandSubcommandBuilder()
-                .setName(sub.name)
-                .setDescription(sub.description);
-            if (sub?.args?.length > 0) {
-                this.addOptions(subCommand, sub.args)
-            }
-            where.addSubcommand(subCommand);
-        }
-    }
-
-    addSubcommandGroups(groups) {
-        for (const group of groups) {
-            let subcommandGroup = new SlashCommandSubcommandGroupBuilder()
-                .setName(group.name)
-                .setDescription(group.description)
-
-            if (group?.subs?.length > 0) {
-                this.addSubcommands(subcommandGroup, group.subs)
-                if (group?.subs?.args) {
-                    this.addOptions(group.subs, group.subs.args)
-                }
-            }
-            this.data.addSubcommandGroup(subcommandGroup);
-        }
-    }
-}
-
-module.exports = { InteractionCommand };

package/models/commands/MessageCommand.js

@@ -1,86 +0,0 @@
-const { s } = require('@sapphire/shapeshift');
-
-/**
- * @param {string} name - The name of the command. @required
- * @param {string} aliases - Optional aliases of the command.
- * @param {string} description - The brief description of the command. @required
- * @param {string} detailedDescription - The detailed description of the command.
- * @param {boolean} owner - Wether the command can be executed by the bot owner only or not.
- * @param {boolean} admin - Wether the command can be executed by the guild admins only or not.
- * @param {string} channel - Whether the command can only be executed in a DM, a Guild, or both.
- * @param {string} separator - A string used to separate arguments.
- */
-class MessageCommand {
-    constructor(id, options = {}) {
-
-        s.object({
-            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,
-            channel: s.string.optional,
-            separator: s.string.optional,
-            category: s.string.optional,
-            cooldown: s.number.optional,
-            ignoreOwner: s.boolean.optional,
-            inVoice: s.boolean.optional,
-            channels: s.array(s.string).optional,
-            guilds: s.array(s.string).optional,
-            userPermissions: s.array(s.string).optional,
-            clientPermissions: s.array(s.string).optional
-        }).parse(options);
-
-        this.id = id;
-
-        this.name = options.name;
-
-        this.aliases = [options.name, ...(options.aliases ? options.aliases : [])];
-
-        this.regex = options.regex instanceof RegExp ? String(options.regex) : undefined;
-
-        this.prefix = options.prefix || [];
-
-        this.description = options.description || undefined;
-
-        this.owner = options.owner || undefined;
-
-        this.admin = options.admin || undefined;
-
-        this.channel = options.channel || undefined;
-
-        this.separator = options.separator || ' '
-
-        this.args = options.args;
-
-        this.category = options.category || undefined;
-
-        this.config = options.config;
-
-        this.cooldown = options.cooldown || 0;
-
-        this.ignoreOwner = options.ignoreOwner || false;
-
-        this.inVoice = options.inVoice || false;
-
-        this.info = options.info || undefined;
-
-        this.channels = options.channels || [];
-
-        this.guilds = options.guilds || [];
-
-        this.userPermissions = options.userPermissions || [];
-
-        this.clientPermissions = options.clientPermissions || [];
-    }
-
-    exec(message) {
-        /*
-         * Make your custom command here.
-         */
-    }
-}
-
-module.exports = { MessageCommand };

package/models/data/colors.json

@@ -1,16 +0,0 @@
-{
-  "red": "#ff0000",
-  "orange": "#ff8000",
-  "yellow": "#ffff00",
-  "chartreuse": "#80ff00",
-  "green": "#00ff00",
-  "springGreen": "#00ff80",
-  "cyan": "#00ffff",
-  "dodgerBlue": "#0080ff",
-  "blue": "#0000ff",
-  "purple": "#8000ff",
-  "violet": "#ff00ff",
-  "magenta": "#ff0080",
-  "black": "#000000",
-  "white": "#FFFFFF"
-}

package/models/data/options.json

@@ -1,27 +0,0 @@
-[
-  "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,84 +0,0 @@
-const { Event } = require('../commands/Event.js');
-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.
- */
-class BuildInInteractionEvent extends Event {
-    constructor() {
-        super('interactionCreate', {
-            name: 'interactionCreate',
-            type: 'client',
-            once: false,
-        })
-    }
-
-    async run(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 (await inhibitorsValidation(interaction, command)) return;
-
-                await this.defer(interaction, command);
-
-                command.client = interaction.client;
-
-                const group = interactionArgs(interaction).group;
-
-                const subcommand = interactionArgs(interaction).sub;
-
-                const args = interactionArgs(interaction).options;
-
-                if (commandValidation(interaction, command)) return;
-
-                try {
-                    if (command.conditions && await command.conditions(interaction, { group, subcommand, args })) return;
-
-                    await command.exec(interaction, { group, subcommand, args });
-
-                    return interaction.client.emit('commandRun', interaction, "interaction", command)
-                }
-                catch (error) {
-                    return interaction.client.emit("error", interaction, error);
-                }
-            }
-
-            if (interaction.client.commands.contextMenu.has(interaction.commandName)) {
-                let command = interaction.client.commands.contextMenu.get(interaction.commandName);
-
-                if (await inhibitorsValidation(interaction, command)) return;
-
-                await this.defer(interaction, command);
-
-                command.client = interaction.client;
-
-                try {
-                    if (command.conditions && await command.conditions(interaction)) return;
-
-                    await command.exec(interaction);
-
-                    return interaction.client.emit('commandRun', interaction, 'contextMenu', command);
-                }
-                catch (error) {
-                    return interaction.client.emit("error", interaction, error);
-                }
-            }
-        }
-    }
-
-    async defer(interaction, command) {
-        if (command?.defer?.reply) return await interaction.deferReply({ ephemeral: command?.defer?.ephemeral });
-
-        else if (command?.defer?.reply === false && interaction.client?.settings?.defer?.reply) return;
-
-        else if (interaction.client?.settings?.defer?.reply) return await interaction.deferReply({ ephemeral: interaction.client?.settings?.defer?.ephemeral || command?.defer?.ephemeral });
-    }
-}
-
-module.exports = BuildInInteractionEvent;

package/models/events/messageCreate.js

@@ -1,84 +0,0 @@
-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.
- */
-class BuildInMessageEvent extends Event {
-    constructor() {
-        super('messageCreate', {
-            name: 'messageCreate',
-            type: 'client',
-            once: false,
-        })
-    }
-
-    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 && !message.client.settings.mentionPrefix) return;
-
-            commands.filter(c => !c.regex).map(async command => {
-                command?.prefix?.map(prefix => {
-                    this.commandCheck(message, prefix, command);
-                })
-
-                if (message.client.settings.mentionPrefix && !message.client.settings.prefix.includes(`<@${message.client.user.id}>`)) message.client.settings.prefix.push(`<@${message.client.user.id}>`)
-
-                message.client.settings.prefix.map(prefix => {
-                    this.commandCheck(message, prefix, command);
-                });
-            })
-        }
-    }
-
-    async commandCheck(message, prefix, command) {
-        for (const alias of command.aliases) {
-            if (message.content.split(/ +/)[0] !== prefix + alias) continue;
-
-            if (await inhibitorsValidation(message, command)) break;
-
-            const args = await messageArgs({ message: message, command: command });
-
-            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;
-            }
-        }
-    }
-};
-
-module.exports = BuildInMessageEvent;

package/models/events/messageUpdate.js

@@ -1,83 +0,0 @@
-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.
- */
-class BuildInMessageUpdateEvent extends Event {
-    constructor() {
-        super('messageUpdate', {
-            name: 'messageUpdate',
-            type: 'client',
-            once: false,
-        })
-    }
-
-    async run(oldMessage, newMessage) {
-        if (!oldMessage.author.bot && !newMessage.author.bot) {
-            await messageUtil(newMessage, "edit");
-
-            let commands = newMessage.client.commands.message;
-
-            commands.filter(c => c.regex).map(async command => {
-                let regex = command.regex.split(/\//).slice(1);
-
-                regex = RegExp(...regex);
-
-                if (newMessage.content.match(regex)) {
-                    try {
-                        if (command.conditions && (await command.conditions(newMessage))) return;
-
-                        return await command.exec(newMessage);
-                    }
-                    catch (error) {
-                        newMessage.client.emit("error", newMessage, error);
-                    }
-                };
-            })
-
-            if (newMessage?.client?.settings?.prefix?.length <= 0) return;
-
-            if (!newMessage.client.data.messages[newMessage.id] === undefined) return;
-
-            commands.filter(c => !c.regex).map(async command => {
-                command?.prefix?.map(prefix => {
-                    this.commandCheck(newMessage, prefix, command);
-                })
-
-                newMessage.client.settings.prefix.map(prefix => {
-                    this.commandCheck(newMessage, prefix, command);
-                });
-            })
-        }
-    }
-
-    async commandCheck(message, prefix, command) {
-        for (const alias of command.aliases) {
-            if (message.content.split(/ +/)[0] !== prefix + alias) continue;
-
-            if (await inhibitorsValidation(message, command)) break;
-
-            const args = await messageArgs({ message: message, command: command });
-
-            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;
-            }
-        }
-    }
-};
-
-module.exports = BuildInMessageUpdateEvent;

package/models/events/readyOnce.js

@@ -1,58 +0,0 @@
-const { Event } = require('../commands/Event.js');
-const { logStyle } = require('dumfunctions');
-
-/**
- * @returns message command executor.
- */
-class BuildInReadyOnceEvent extends Event {
-    constructor() {
-        super('ready', {
-            name: 'ready',
-            once: true,
-        })
-    }
-
-    async run(client) {
-        if (client.settings.logging) console.info(logStyle(`${client.user.tag} is online in ${(await client.guilds.fetch()).size} servers.`, "text", "cyan"));
-
-        if (Array.isArray(client.settings.logging)) {
-            let loaded = [];
-
-            for (const [type, commands] of Object.entries(client.commands)) {
-                for (let [id, command] of commands) {
-                    command.name = command?.data?.name || command?.aliases[0] || command.id;
-
-                    command.description = command?.data?.description || command.description;
-
-                    command.runType = type;
-
-                    if (!loaded.includes(command)) loaded.push(command);
-                }
-            }
-
-            for (const [id, event] of [...client.events]) {
-                event.runType = '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;
-        }
-    }
-
-};
-
-module.exports = BuildInReadyOnceEvent;

package/models/handlers/CommandHandler.js

@@ -1,37 +0,0 @@
-const Discord = require('discord.js');
-const Handler = require('./Handler.js');
-
-/**
- * @param {object} client - The client.
- * @returns a command handler.
- */
-class CommandHandler {
-    constructor({ client: client }) {
-
-        this.client = client;
-
-        client.commands = {
-            message: new Discord.Collection(),
-
-            interaction: new Discord.Collection(),
-
-            contextMenu: new Discord.Collection()
-        }
-
-        this.load = new Handler(client);
-    }
-
-    loadAllInteractionCommands(path, logging = false) {
-        this.load.loadAllInteractionCommands(path, logging);
-    }
-
-    loadAllContextMenuCommands(path, logging = false) {
-        this.load.loadAllContextMenuCommands(path, logging);
-    }
-
-    loadAllMessageCommands(path, logging = false) {
-        this.load.loadAllMessageCommands(path, logging);
-    }
-}
-
-module.exports = { CommandHandler };

package/models/handlers/EventHandler.js

@@ -1,67 +0,0 @@
-const fs = require('fs');
-const Discord = require('discord.js');
-
-/**
- * @param {object} client - Client object.
- */
-class EventHandler {
-    constructor({ client: client }) {
-        this.client = client;
-
-        client.events = new Discord.Collection()
-    }
-
-    loadAllEvents(path, logging) {
-        const eventFiles = fs.readdirSync(path).filter(file => file.endsWith('.js'))
-
-        for (const file of eventFiles) {
-            let event = require(`${require("path").resolve(path)}/${file}`);
-
-            event = new event;
-
-            event.client = this.client;
-
-            this.client.events.set(event.name, event);
-
-            if (event.once) {
-                this.emitter(event.type).once(event.name, (...args) => {
-                    event.run(...args)
-                })
-            }
-            else {
-                this.emitter(event.type).on(event.name, (...args) => {
-                    event.run(...args)
-                })
-            }
-        }
-
-        const builderFiles = fs.readdirSync(`${__dirname}/../events`).filter(file => file.endsWith('.js'))
-
-        for (const file of builderFiles) {
-            let event = require(`../events/${file}`);
-
-            event = new event;
-
-            if (event.once) {
-                this.emitter(event.type).once(event.name, (...args) => {
-                    event.run(...args)
-                })
-            }
-            else {
-                this.emitter(event.type).on(event.name, (...args) => {
-                    event.run(...args)
-                })
-            }
-        }
-    }
-
-    emitter(type) {
-        const client = this.client;
-
-        if (type == 'client') return client;
-        if (type == 'rest') return client.rest;
-        else return eval(type);
-    }
-}
-
-module.exports = { EventHandler };