spacecommands 1.0.0

package/dist/commands/help/!ReactionListener.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addReactions = void 0;
+const _get_first_embed_1 = __importDefault(require("./!get-first-embed"));
+const /**
+   * Recursively adds reactions to the message
+   * @param message The message to react to
+   * @param reactions A list of reactions to add
+   */ addReactions = (message, reactions) => {
+    const emoji = reactions.shift();
+    if (emoji) {
+        message.react(emoji);
+        addReactions(message, reactions);
+    }
+};
+exports.addReactions = addReactions;
+class ReactionHandler {
+    instance;
+    reaction;
+    user;
+    message;
+    embed;
+    guild = null;
+    emojiName = '';
+    emojiId = '';
+    door = '🚪';
+    pageLimit = 3;
+    constructor(instance, reaction, user) {
+        this.instance = instance;
+        this.reaction = reaction;
+        this.user = user;
+        this.message = reaction.message;
+        this.init();
+    }
+    init = async () => {
+        if (this.message.partial) {
+            await this.message.fetch();
+        }
+        const { embeds, guild } = this.message;
+        if (this.user.bot || !embeds || embeds.length !== 1) {
+            return;
+        }
+        this.embed = embeds[0];
+        this.guild = guild;
+        if (!this.canUserInteract()) {
+            return;
+        }
+        this.emojiName = this.reaction.emoji.name;
+        this.emojiId = this.reaction.emoji.id || '';
+        this.handleEmoji();
+    };
+    /**
+     * @returns If the bot has access to remove reactions from the help menu
+     */
+    canBotRemoveReaction = () => {
+        return (this.message.channel.type !== 'DM' &&
+            this.message.member?.permissions.has('ManageMessages'));
+    };
+    /**
+     * @returns If the user is allowed to interact with this help menu
+     */
+    canUserInteract = () => {
+        // Check if the title of the embed is correct
+        const displayName = this.instance.displayName
+            ? this.instance.displayName + ' '
+            : '';
+        const isSameTitle = this.embed.title ===
+            `${displayName}${this.instance.messageHandler.getEmbed(this.guild, 'HELP_MENU', 'TITLE')}`;
+        if (!isSameTitle) {
+            return false;
+        }
+        // Check if the user's ID is in the footer
+        if (this.embed.footer) {
+            const { text } = this.embed.footer;
+            const id = text?.split('#')[1];
+            if (id !== this.user.id) {
+                if (this.canBotRemoveReaction()) {
+                    this.reaction.users.remove(this.user.id);
+                }
+                return false;
+            }
+        }
+        return true;
+    };
+    /**
+     * Invoked when the user returns to the main menu
+     */
+    returnToMainMenu = () => {
+        const { embed: newEmbed, reactions } = (0, _get_first_embed_1.default)(this.message, this.instance);
+        this.embed.setDescription(newEmbed.description || '');
+        this.message.edit({ embeds: [this.embed] });
+        if (this.canBotRemoveReaction()) {
+            this.message.reactions.removeAll();
+        }
+        addReactions(this.message, reactions);
+    };
+    /**
+     * @param commandLength How many commands are in the category
+     * @returns An array of [page, maxPages]
+     */
+    getMaxPages = (commandLength) => {
+        let page = 1;
+        if (this.embed && this.embed.description) {
+            const split = this.embed.description.split('\n');
+            const lastLine = split[split.length - 1];
+            if (lastLine.startsWith('Page ')) {
+                page = parseInt(lastLine.split(' ')[1]);
+            }
+        }
+        return [page, Math.ceil(commandLength / this.pageLimit)];
+    };
+    /**
+     * @returns An object containing information regarding the commands
+     */
+    getCommands = () => {
+        let category = this.instance.getCategory(this.emojiId || this.emojiName);
+        const commandsString = this.instance.messageHandler.getEmbed(this.guild, 'HELP_MENU', 'COMMANDS');
+        if (this.embed.description) {
+            const split = this.embed.description.split('\n');
+            const cmdStr = ' ' + commandsString;
+            if (split[0].endsWith(cmdStr)) {
+                category = split[0].replace(cmdStr, '');
+            }
+        }
+        const commands = this.instance.commandHandler.getCommandsByCategory(category);
+        return {
+            length: commands.length,
+            commands,
+            commandsString,
+            category,
+        };
+    };
+    static getHelp = (command, instance, guild) => {
+        const { description, syntax, names } = command;
+        if (names === undefined) {
+            console.error('SpaceCommands > A command does not have a name assigned to it.');
+            return '';
+        }
+        const mainName = typeof names === 'string' ? names : names.shift();
+        let desc = `**${mainName}**${description ? ' - ' : ''}${description}`;
+        if (names.length && typeof names !== 'string') {
+            desc += `\n${instance.messageHandler.getEmbed(guild, 'HELP_MENU', 'ALIASES')}: "${names.join('", "')}"`;
+        }
+        desc += `\n${instance.messageHandler.getEmbed(guild, 'HELP_MENU', 'SYNTAX')}: "${instance.getPrefix(guild)}${mainName}${syntax ? ' ' : ''}${syntax || ''}"`;
+        return desc;
+    };
+    /**
+     * Generates the actual menu
+     */
+    generateMenu = (page, maxPages) => {
+        const { length, commands, commandsString, category } = this.getCommands();
+        const hasMultiplePages = length > this.pageLimit;
+        let desc = `${category} ${commandsString}\n\n${this.instance.messageHandler.getEmbed(this.guild, 'HELP_MENU', 'DESCRIPTION_FIRST_LINE')}`;
+        if (hasMultiplePages) {
+            desc += `\n\n${this.instance.messageHandler.getEmbed(this.guild, 'HELP_MENU', 'DESCRIPTION_SECOND_LINE')}`;
+        }
+        const start = (page - 1) * this.pageLimit;
+        for (let a = start, counter = a; a < commands.length && a < start + this.pageLimit; ++a) {
+            const command = commands[a];
+            let { hidden, category, names } = command;
+            if (!hidden && category === category) {
+                if (typeof names === 'string') {
+                    // @ts-ignore
+                    names = [...names];
+                }
+                desc += `\n\n#${++counter}) ${ReactionHandler.getHelp(command, this.instance, this.guild)}`;
+            }
+        }
+        desc += `\n\nPage ${page} / ${maxPages}.`;
+        this.embed.setDescription(desc);
+        this.message.edit({ embeds: [this.embed] });
+        if (this.canBotRemoveReaction()) {
+            this.message.reactions.removeAll();
+        }
+        const reactions = [];
+        if (hasMultiplePages) {
+            reactions.push('⬅');
+            reactions.push('➡');
+        }
+        reactions.push('🚪');
+        addReactions(this.message, reactions);
+    };
+    /**
+     * Handles the input from the emoji
+     */
+    handleEmoji = () => {
+        if (this.emojiName === this.door) {
+            this.returnToMainMenu();
+            return;
+        }
+        const { length } = this.getCommands();
+        let [page, maxPages] = this.getMaxPages(length);
+        if (this.emojiName === '⬅') {
+            if (page <= 1) {
+                if (this.canBotRemoveReaction()) {
+                    this.reaction.users.remove(this.user.id);
+                }
+                return;
+            }
+            --page;
+        }
+        else if (this.emojiName === '➡') {
+            if (page >= maxPages) {
+                if (this.canBotRemoveReaction()) {
+                    this.reaction.users.remove(this.user.id);
+                }
+                return;
+            }
+            ++page;
+        }
+        this.generateMenu(page, maxPages);
+    };
+}
+exports.default = ReactionHandler;

package/dist/commands/help/!get-first-embed.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const discord_js_1 = require("discord.js");
+const getFirstEmbed = (message, instance) => {
+    const { guild, member } = message;
+    const { commandHandler: { commands }, messageHandler, } = instance;
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle(`${instance.displayName} ${messageHandler.getEmbed(guild, 'HELP_MENU', 'TITLE')}`)
+        .setDescription(messageHandler.getEmbed(guild, 'HELP_MENU', 'SELECT_A_CATEGORY'))
+        .setFooter(`ID #${message.author?.id}`);
+    if (instance.color) {
+        embed.setColor(instance.color);
+    }
+    const categories = {};
+    const isAdmin = member && member.permissions.has('Administrator');
+    for (const { category, testOnly } of commands) {
+        if (!category ||
+            (testOnly && guild && !instance.testServers.includes(guild.id)) ||
+            (!isAdmin && instance.hiddenCategories.includes(category))) {
+            continue;
+        }
+        if (categories[category]) {
+            ++categories[category].amount;
+        }
+        else {
+            categories[category] = {
+                amount: 1,
+                emoji: instance.getEmoji(category),
+            };
+        }
+    }
+    const reactions = [];
+    const keys = Object.keys(categories);
+    for (let a = 0; a < keys.length; ++a) {
+        const key = keys[a];
+        const { emoji } = categories[key];
+        if (!emoji) {
+            console.warn(`SpaceCommands > Category "${key}" does not have an emoji icon.`);
+            continue;
+        }
+        const visibleCommands = instance.commandHandler.getCommandsByCategory(key, true);
+        const amount = visibleCommands.length;
+        if (amount === 0) {
+            continue;
+        }
+        const reaction = emoji;
+        reactions.push(reaction);
+        embed.setDescription(embed.description +
+            `\n\n**${reaction} - ${key}** - ${amount} command${amount === 1 ? '' : 's'}`);
+    }
+    return {
+        embed,
+        reactions,
+    };
+};
+exports.default = getFirstEmbed;

package/dist/commands/help/help.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const discord_js_1 = require("discord.js");
+const _get_first_embed_1 = __importDefault(require("./!get-first-embed"));
+const _ReactionListener_1 = __importStar(require("./!ReactionListener"));
+const sendHelpMenu = (message, instance) => {
+    const { embed, reactions } = (0, _get_first_embed_1.default)(message, instance);
+    message.channel
+        .send({
+        embeds: [embed],
+    })
+        .then((message) => {
+        (0, _ReactionListener_1.addReactions)(message, reactions);
+    });
+};
+module.exports = {
+    description: "Displays this bot's commands",
+    category: 'Help',
+    aliases: 'commands',
+    maxArgs: 1,
+    expectedArgs: '[command]',
+    init: (client, instance) => {
+        client.on('messageReactionAdd', async (reaction, user) => {
+            new _ReactionListener_1.default(instance, reaction, user);
+        });
+    },
+    callback: (options) => {
+        const { message, channel, instance, args } = options;
+        const { guild } = channel;
+        if (guild && !guild.me?.permissions.has('SEND_MESSAGES')) {
+            console.warn(`SpaceCommands > Could not send message due to no permissions in channel for ${guild.name}`);
+            return;
+        }
+        if (guild && !guild.me?.permissions.has('ADD_REACTIONS')) {
+            return instance.messageHandler.get(guild, 'NO_REACT_PERMS');
+        }
+        // Typical "!help" syntax for the menu
+        if (args.length === 0) {
+            sendHelpMenu(message, instance);
+            return;
+        }
+        // If the user is looking for info on a specific command
+        // Ex: "!help prefix"
+        const arg = args.shift()?.toLowerCase();
+        const command = instance.commandHandler.getICommand(arg);
+        if (!command) {
+            return instance.messageHandler.get(guild, 'UNKNOWN_COMMAND', {
+                COMMAND: arg,
+            });
+        }
+        const description = _ReactionListener_1.default.getHelp(command, instance, guild);
+        const embed = new discord_js_1.EmbedBuilder()
+            .setTitle(`${instance.displayName} ${instance.messageHandler.getEmbed(guild, 'HELP_MENU', 'TITLE')} - ${arg}`)
+            .setDescription(description);
+        if (instance.color) {
+            embed.setColor(instance.color);
+        }
+        return embed;
+    },
+};

package/dist/commands/language.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+// @ts-nocheck
+const languages_1 = __importDefault(require("../models/languages"));
+const Events_1 = __importDefault(require("../enums/Events"));
+module.exports = {
+    description: 'Displays or sets the language for this Discord server',
+    category: 'Configuration',
+    aliases: ['lang'],
+    permissions: ['Administrator'],
+    maxArgs: 1,
+    expectedArgs: '[language]',
+    cooldown: '2s',
+    slash: 'both',
+    callback: async (options) => {
+        const { channel, text, instance } = options;
+        const { guild } = channel;
+        if (!guild) {
+            return;
+        }
+        const { messageHandler } = instance;
+        if (!instance.isDBConnected()) {
+            return instance.messageHandler.get(guild, 'NO_DATABASE_FOUND');
+        }
+        const lang = text.toLowerCase();
+        if (!lang) {
+            return instance.messageHandler.get(guild, 'CURRENT_LANGUAGE', {
+                LANGUAGE: instance.messageHandler.getLanguage(guild),
+            });
+        }
+        if (!messageHandler.languages().includes(lang)) {
+            instance.emit(Events_1.default.LANGUAGE_NOT_SUPPORTED, guild, lang);
+            return messageHandler.get(guild, 'LANGUAGE_NOT_SUPPORTED', {
+                LANGUAGE: lang,
+            });
+        }
+        instance.messageHandler.setLanguage(guild, lang);
+        await languages_1.default.findOneAndUpdate({
+            _id: guild.id,
+        }, {
+            _id: guild.id,
+            language: lang,
+        }, {
+            upsert: true,
+        });
+        return instance.messageHandler.get(guild, 'NEW_LANGUAGE', {
+            LANGUAGE: lang,
+        });
+    },
+};

package/dist/commands/prefix.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const prefixes_1 = __importDefault(require("../models/prefixes"));
+module.exports = {
+    description: 'Displays or sets the prefix for the current guild',
+    category: 'Configuration',
+    permissions: ['Administrator'],
+    maxArgs: 1,
+    expectedArgs: '[prefix]',
+    cooldown: '2s',
+    slash: 'both',
+    callback: async (options) => {
+        const { channel, args, text, instance } = options;
+        const { guild } = channel;
+        if (args.length === 0) {
+            return instance.messageHandler.get(guild, 'CURRENT_PREFIX', {
+                PREFIX: instance.getPrefix(guild),
+            });
+        }
+        if (guild) {
+            const { id } = guild;
+            if (!instance.isDBConnected()) {
+                return instance.messageHandler.get(guild, 'NO_DATABASE_FOUND');
+            }
+            await prefixes_1.default.findOneAndUpdate({
+                _id: id,
+            }, {
+                _id: id,
+                prefix: text,
+            }, {
+                upsert: true,
+            });
+            instance.setPrefix(guild, text);
+            return instance.messageHandler.get(guild, 'SET_PREFIX', {
+                PREFIX: text,
+            });
+        }
+        return instance.messageHandler.get(guild, 'CANNOT_SET_PREFIX_IN_DMS');
+    },
+};

package/dist/commands/requiredrole.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const required_roles_1 = __importDefault(require("../models/required-roles"));
+module.exports = {
+    description: 'Specifies what role each command requires.',
+    category: 'Configuration',
+    permissions: ['Administrator'],
+    aliases: ['requiredroles', 'requirerole', 'requireroles'],
+    minArgs: 2,
+    maxArgs: 2,
+    expectedArgs: '<command> <none-or-roleid>',
+    cooldown: '2s',
+    slash: 'both',
+    callback: async (options) => {
+        const { channel, args, instance } = options;
+        const name = (args.shift() || '').toLowerCase();
+        const roleId = (args.shift() || '').toLowerCase();
+        const { guild } = channel;
+        if (!guild) {
+            return instance.messageHandler.get(guild, 'CANNOT_CHANGE_REQUIRED_ROLES_IN_DMS');
+        }
+        if (!instance.isDBConnected()) {
+            return instance.messageHandler.get(guild, 'NO_DATABASE_FOUND');
+        }
+        const command = instance.commandHandler.getCommand(name);
+        if (command) {
+            if (roleId === 'none') {
+                command.removeRequiredRole(guild.id, roleId);
+                await required_roles_1.default.deleteOne({
+                    guildId: guild.id,
+                    command: command.names[0],
+                });
+                return instance.messageHandler.get(guild, 'REMOVED_ALL_REQUIRED_ROLES', {
+                    COMMAND: command.names[0],
+                });
+            }
+            command.addRequiredRole(guild.id, roleId);
+            await required_roles_1.default.findOneAndUpdate({
+                guildId: guild.id,
+                command: command.names[0],
+            }, {
+                guildId: guild.id,
+                command: command.names[0],
+                $addToSet: {
+                    requiredRoles: roleId,
+                },
+            }, {
+                upsert: true,
+            });
+            return instance.messageHandler.get(guild, 'ADDED_REQUIRED_ROLE', {
+                ROLE: roleId,
+                COMMAND: command.names[0],
+            });
+        }
+        return instance.messageHandler.get(guild, 'UNKNOWN_COMMAND', {
+            COMMAND: name,
+        });
+    },
+};

package/dist/commands/slash.js

@@ -0,0 +1,102 @@
+"use strict";
+const discord_js_1 = require("discord.js");
+module.exports = {
+    description: 'Allows the bot developers to manage existing slash commands',
+    category: 'Configuration',
+    permissions: ['Administrator'],
+    maxArgs: 1,
+    expectedArgs: '[command-id]',
+    ownerOnly: true,
+    hidden: true,
+    slash: 'both',
+    callback: async (options) => {
+        const { channel, instance, text } = options;
+        const { guild } = channel;
+        const { slashCommands } = instance;
+        const global = await slashCommands.get();
+        if (text) {
+            let useGuild = true;
+            try {
+                global?.forEach((cmd) => {
+                    if (cmd.id === text) {
+                        useGuild = false;
+                        throw new Error('');
+                    }
+                });
+            }
+            catch (ignored) { }
+            slashCommands.delete(text, useGuild ? guild.id : undefined);
+            if (useGuild) {
+                return `Slash command with the ID "${text}" has been deleted from guild "${guild.id}".`;
+            }
+            return `Slash command with the ID "${text}" has been deleted. This may take up to 1 hour to be seen on all servers using your bot.`;
+        }
+        let counter = 0;
+        let allSlashCommands = [];
+        if (global.size) {
+            global.forEach((cmd) => {
+                if (cmd && cmd.name) {
+                    const newString = `${cmd.name}: ${cmd.id}\n`;
+                    if ((allSlashCommands[counter] || []).length + newString.length <
+                        1024) {
+                        allSlashCommands[counter] ??= '';
+                        allSlashCommands[counter] += newString;
+                    }
+                    else {
+                        ++counter;
+                        allSlashCommands[counter] ??= '';
+                        allSlashCommands[counter] += newString;
+                    }
+                }
+            });
+        }
+        else {
+            allSlashCommands.push('None');
+        }
+        const embed = new discord_js_1.EmbedBuilder().addFields({
+            name: 'How to delete a slash command:',
+            value: `${instance.getPrefix(guild)}slash <command-id>`,
+        });
+        for (let a = 0; a < allSlashCommands.length; ++a) {
+            embed.addFields({
+                name: `Global slash commands:${a === 0 ? '' : ' (Continued)'}`,
+                value: allSlashCommands[a],
+            });
+        }
+        if (guild) {
+            const guildOnly = await slashCommands.get(guild.id);
+            counter = 0;
+            let guildOnlyCommands = [];
+            if (guildOnly.size) {
+                guildOnly.forEach((cmd) => {
+                    if (cmd && cmd.name) {
+                        const newString = `${cmd.name}: ${cmd.id}\n`;
+                        if ((guildOnlyCommands[counter] || []).length + newString.length <
+                            1024) {
+                            guildOnlyCommands[counter] ??= '';
+                            guildOnlyCommands[counter] += newString;
+                        }
+                        else {
+                            ++counter;
+                            guildOnlyCommands[counter] ??= '';
+                            guildOnlyCommands[counter] += newString;
+                        }
+                    }
+                });
+            }
+            else {
+                guildOnlyCommands[0] = 'None';
+            }
+            for (let a = 0; a < guildOnlyCommands.length; ++a) {
+                embed.addFields({
+                    name: `Guild slash commands:${a === 0 ? '' : ' (Continued)'}`,
+                    value: guildOnlyCommands[a],
+                });
+            }
+        }
+        if (instance.color) {
+            embed.setColor(instance.color);
+        }
+        return embed;
+    },
+};

package/dist/enums/CommandErrors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var CommandErrors;
+(function (CommandErrors) {
+    CommandErrors["EXCEPTION"] = "EXCEPTION";
+    CommandErrors["COOLDOWN"] = "COOLDOWN";
+    CommandErrors["INVALID_ARGUMENTS"] = "INVALID ARGUMENTS";
+    CommandErrors["MISSING_PERMISSIONS"] = "MISSING PERMISSIONS";
+    CommandErrors["MISSING_ROLES"] = "MISSING ROLES";
+    CommandErrors["COMMAND_DISABLED"] = "COMMAND DISABLED";
+})(CommandErrors || (CommandErrors = {}));
+exports.default = CommandErrors;

package/dist/enums/Events.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Events;
+(function (Events) {
+    Events["DATABASE_CONNECTED"] = "databaseConnected";
+    Events["LANGUAGE_NOT_SUPPORTED"] = "languageNotSupported";
+    Events["COMMAND_EXCEPTION"] = "commandException";
+})(Events || (Events = {}));
+exports.default = Events;

package/dist/features/message-upsert.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = (client) => {
+    client.on('messageCreate', (message) => {
+        client.emit('messageUpsert', message);
+    });
+    client.on('messageUpdate', (oldMessage, newMessage) => {
+        client.emit('messageUpsert', newMessage, oldMessage);
+    });
+};
+exports.config = {
+    displayName: 'Message Upsert',
+    dbName: 'MESSAGE-UPSERT',
+};