@fjrodafo/discord-app 1.0.0

package/src/commands/help/help.js

@@ -0,0 +1,154 @@
+const {
+    SlashCommandBuilder,
+    PermissionFlagsBits,
+    EmbedBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+    ActionRowBuilder,
+    ComponentType,
+} = require('discord.js');
+const fs = require('fs');
+const path = require('path');
+const emoji = require('./../../utils/emoji.js');
+
+module.exports = {
+    category: 'help',
+    data: new SlashCommandBuilder()
+        .setName('help')
+        .setDescription('Shows all available commands!')
+        .setDMPermission(false),
+    async execute(interaction) {
+        // Function to recursively read commands from directories
+        function getCommands(dir) {
+            const commandFiles = [];
+            const files = fs.readdirSync(dir);
+
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                const stat = fs.statSync(filePath);
+
+                if (stat.isDirectory()) {
+                    if (file !== 'admin' && file !== 'moderation' && file !== 'context-menu' && file !== 'help') {
+                        commandFiles.push(...getCommands(filePath));
+                    }
+                    if (file === 'admin' && interaction.member.permissions.has(PermissionFlagsBits.Administrator)) {
+                        commandFiles.push(...getCommands(filePath));
+                    }
+                    if (file === 'moderation' && interaction.member.permissions.has(PermissionFlagsBits.KickMembers)) {
+                        commandFiles.push(...getCommands(filePath));
+                    }
+                }
+                else if (file.endsWith('.js')) {
+                    commandFiles.push(filePath);
+                }
+            }
+
+            return commandFiles;
+        }
+
+        const commandsDir = path.join(__dirname, './../../commands');
+        const commandFiles = getCommands(commandsDir);
+
+        const commands = commandFiles.map(file => {
+            const command = require(file);
+            // Get the category (folder name)
+            const category = path.basename(path.dirname(file));
+
+            return {
+                name: `${command.data.name} (${category})`,
+                description: command.data.description || 'No description',
+            };
+        });
+
+        // Divide commands into pages of 5 commands each
+        const commandsPerPage = 5;
+        const totalPages = Math.ceil(commands.length / commandsPerPage);
+
+        const pages = [];
+        for (let i = 0; i < commands.length; i += commandsPerPage) {
+            const page = new EmbedBuilder()
+                .setColor(0x5865f2)
+                .setTitle('All available commands:')
+                .setDescription('You have one minute to turn the page until the buttons are disabled...')
+                .setFooter({ text: `Page ${Math.floor(i / commandsPerPage) + 1} of ${totalPages}` });
+
+            for (let j = i; j < i + commandsPerPage && j < commands.length; j++) {
+                page.addFields({ name: '/' + commands[j].name, value: commands[j].description });
+            }
+
+            pages.push(page);
+        }
+
+        let currentPage = 0;
+
+        // Create the pagination buttons
+        const firstPageButton = new ButtonBuilder()
+            .setCustomId('first-page-button')
+            .setLabel(emoji.arrow_up)
+            .setStyle(ButtonStyle.Primary)
+            .setDisabled(true);
+
+        const backButton = new ButtonBuilder()
+            .setCustomId('back-button')
+            .setLabel(emoji.arrow_left)
+            .setStyle(ButtonStyle.Primary)
+            .setDisabled(true);
+
+        const nextButton = new ButtonBuilder()
+            .setCustomId('next-button')
+            .setLabel(emoji.arrow_right)
+            .setStyle(ButtonStyle.Primary)
+            .setDisabled(totalPages === 1);
+
+        const lastPageButton = new ButtonBuilder()
+            .setCustomId('last-page-button')
+            .setLabel(emoji.arrow_down)
+            .setStyle(ButtonStyle.Primary)
+            .setDisabled(totalPages === 1);
+
+        const buttonRow = new ActionRowBuilder().addComponents(firstPageButton, backButton, nextButton, lastPageButton);
+
+        // Send the initial embed with buttons
+        const reply = await interaction.reply({
+            embeds: [pages[currentPage]],
+            components: [buttonRow],
+            ephemeral: true,
+        });
+
+        // Create an event collector for the buttons
+        const collector = reply.createMessageComponentCollector({
+            componentType: ComponentType.Button,
+            filter: (i) => i.user.id === interaction.user.id,
+            time: 120_000,
+        });
+
+        collector.on('collect', async (i) => {
+            if (i.customId === 'first-page-button') currentPage = 0;
+            if (i.customId === 'back-button') currentPage--;
+            if (i.customId === 'next-button') currentPage++;
+            if (i.customId === 'last-page-button') currentPage = totalPages - 1;
+
+            // Update button states based on the current page
+            firstPageButton.setDisabled(currentPage === 0);
+            backButton.setDisabled(currentPage === 0);
+            nextButton.setDisabled(currentPage === totalPages - 1);
+            lastPageButton.setDisabled(currentPage === totalPages - 1);
+
+            await i.update({
+                embeds: [pages[currentPage]],
+                components: [buttonRow],
+            });
+        });
+
+        collector.on('end', async () => {
+            firstPageButton.setDisabled(true);
+            backButton.setDisabled(true);
+            nextButton.setDisabled(true);
+            lastPageButton.setDisabled(true);
+
+            await interaction.editReply({
+                components: [buttonRow],
+            });
+        });
+    },
+};

package/src/commands/moderation/kick.js

@@ -0,0 +1,23 @@
+const {
+    SlashCommandBuilder,
+    PermissionFlagsBits,
+} = require('discord.js');
+
+module.exports = {
+    category: 'moderation',
+    data: new SlashCommandBuilder()
+        .setName('kick')
+        .setDescription('Select a member and kick them (but not really).')
+        .setDefaultMemberPermissions(PermissionFlagsBits.KickMembers)
+        .setDMPermission(false)
+        .addUserOption(option => option
+            .setName('target')
+            .setDescription('The member to kick')
+            .setRequired(true),
+        ),
+    async execute(interaction) {
+        const user = interaction.options.getUser('target');
+
+        await interaction.reply({ content: `You wanted to kick: ${user} :scales:`, ephemeral: true });
+    },
+};

package/src/commands/utility/buttons.js

@@ -0,0 +1,83 @@
+const {
+    SlashCommandBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+    ActionRowBuilder,
+    ComponentType,
+} = require('discord.js');
+const emoji = require('./../../utils/emoji.js');
+
+module.exports = {
+    category: 'utility',
+    data: new SlashCommandBuilder()
+        .setName('buttons')
+        .setDescription('Press the buttons!')
+        .setDMPermission(false),
+    async execute(interaction) {
+        const primaryButton = new ButtonBuilder()
+            .setCustomId('primary-button')
+            .setLabel('Primary button')
+            .setStyle(ButtonStyle.Primary);
+
+        const secondaryButton = new ButtonBuilder()
+            .setCustomId('secondary-button')
+            .setLabel('Secondary button')
+            .setStyle(ButtonStyle.Secondary);
+
+        const successButton = new ButtonBuilder()
+            .setCustomId('success-button')
+            .setEmoji(emoji.white_check_mark)
+            .setLabel('Success button')
+            .setStyle(ButtonStyle.Success);
+
+        const dangerButton = new ButtonBuilder()
+            .setCustomId('danger-button')
+            .setEmoji(emoji.warning)
+            .setLabel('Danger button')
+            .setStyle(ButtonStyle.Danger);
+
+        const linkButton = new ButtonBuilder()
+            .setURL('https://github.com/FJrodafo/DiscordAPP')
+            .setLabel('Link button')
+            .setStyle(ButtonStyle.Link);
+
+        const buttonRow = new ActionRowBuilder().addComponents(
+            primaryButton,
+            secondaryButton,
+            successButton,
+            dangerButton,
+            linkButton,
+        );
+
+        const reply = await interaction.reply({
+            content: 'Press the buttons!',
+            components: [buttonRow],
+            ephemeral: true,
+        });
+
+        const collector = reply.createMessageComponentCollector({
+            componentType: ComponentType.Button,
+            filter: (i) => i.user.id === interaction.user.id,
+            time: 60_000,
+        });
+
+        collector.on('collect', async (i) => {
+            if (i.customId === 'primary-button') i.reply({ content: 'You clicked on the primary button!', ephemeral: true });
+            if (i.customId === 'secondary-button') i.reply({ content: 'You clicked on the secondary button!', ephemeral: true });
+            if (i.customId === 'success-button') i.reply({ content: 'You clicked on the success button!', ephemeral: true });
+            if (i.customId === 'danger-button') i.reply({ content: 'You clicked on the danger button!', ephemeral: true });
+        });
+
+        collector.on('end', async () => {
+            primaryButton.setDisabled(true);
+            secondaryButton.setDisabled(true);
+            successButton.setDisabled(true);
+            dangerButton.setDisabled(true);
+
+            reply.edit({
+                content: 'You run out of time! Try again later...',
+                components: [buttonRow],
+            });
+        });
+    },
+};

package/src/commands/utility/embed.js

@@ -0,0 +1,33 @@
+const {
+    SlashCommandBuilder,
+    EmbedBuilder,
+} = require('discord.js');
+
+module.exports = {
+    category: 'utility',
+    data: new SlashCommandBuilder()
+        .setName('embed')
+        .setDescription('Embed preview!')
+        .setDMPermission(false),
+    async execute(interaction) {
+        const exampleEmbed = new EmbedBuilder()
+            .setColor(0x5865f2)
+            .setTitle('Some title')
+            .setURL('https://discord.js.org/')
+            .setAuthor({ name: 'Some name', iconURL: 'https://i.imgur.com/AfFp7pu.png', url: 'https://discord.js.org' })
+            .setDescription('Some description here')
+            .setThumbnail('https://i.imgur.com/AfFp7pu.png')
+            .addFields(
+                { name: 'Regular field title', value: 'Some value here' },
+                { name: '\u200B', value: '\u200B' },
+                { name: 'Inline field title', value: 'Some value here', inline: true },
+                { name: 'Inline field title', value: 'Some value here', inline: true },
+            )
+            .addFields({ name: 'Inline field title', value: 'Some value here', inline: true })
+            .setImage('https://i.imgur.com/AfFp7pu.png')
+            .setTimestamp()
+            .setFooter({ text: 'Some footer text here', iconURL: 'https://i.imgur.com/AfFp7pu.png' });
+
+        return interaction.reply({ embeds: [exampleEmbed], ephemeral: true });
+    },
+};

package/src/commands/utility/info.js

@@ -0,0 +1,61 @@
+const {
+    SlashCommandBuilder,
+    EmbedBuilder,
+} = require('discord.js');
+
+module.exports = {
+    category: 'utility',
+    data: new SlashCommandBuilder()
+        .setName('info')
+        .setDescription('Get info about the server or the user!')
+        .setDMPermission(false)
+        .addSubcommand(subcommand => subcommand
+            .setName('server')
+            .setDescription('Display info about this server!'),
+        )
+        .addSubcommand(subcommand => subcommand
+            .setName('user')
+            .setDescription('Provides information about the user!')
+            .addUserOption(option => option
+                .setName('target')
+                .setDescription('Choose a user!')
+                .setRequired(false),
+            ),
+        ),
+    async execute(interaction) {
+        const subcommand = interaction.options.getSubcommand();
+
+        if (subcommand === 'server') return handleServerInfo(interaction);
+        else if (subcommand === 'user') return handleUserInfo(interaction);
+    },
+};
+
+async function handleServerInfo(interaction) {
+    const guild = interaction.guild;
+
+    const embed = new EmbedBuilder()
+        .setThumbnail(`${guild.iconURL()}`)
+        .addFields(
+            { name: 'Server Name:', value: `${guild.name}`, inline: true },
+            { name: 'ID:', value: `${guild.id}`, inline: true },
+            { name: 'Total members:', value: `${guild.memberCount}`, inline: true },
+            { name: 'Created at:', value: `${guild.createdAt}`, inline: false },
+        );
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+}
+
+async function handleUserInfo(interaction) {
+    const user = interaction.options.getUser('target') || interaction.user;
+    const member = interaction.options.getMember('target') || interaction.member;
+
+    const embed = new EmbedBuilder()
+        .setThumbnail(`${user.displayAvatarURL()}`)
+        .addFields(
+            { name: 'User:', value: `${user.username}`, inline: true },
+            { name: 'ID:', value: `${user.id}`, inline: true },
+            { name: 'Joined at:', value: `${member.joinedAt}`, inline: false },
+        );
+
+    await interaction.reply({ embeds: [embed], ephemeral: true });
+}

package/src/commands/utility/paginate.js

@@ -0,0 +1,189 @@
+const {
+    SlashCommandBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+    ActionRowBuilder,
+    ComponentType,
+    EmbedBuilder,
+} = require('discord.js');
+const emoji = require('./../../utils/emoji.js');
+
+module.exports = {
+    category: 'utility',
+    data: new SlashCommandBuilder()
+        .setName('paginate')
+        .setDescription('Navigate through pages using buttons!')
+        .setDMPermission(false)
+        .addSubcommand(subcommand => subcommand
+            .setName('two-pages')
+            .setDescription('Example of pagination with two pages!'),
+        )
+        .addSubcommand(subcommand => subcommand
+            .setName('multiple-pages')
+            .setDescription('Example of pagination with multiple pages!'),
+        )
+        .addSubcommand(subcommand => subcommand
+            .setName('too-many-pages')
+            .setDescription('Example of pagination with too many pages!'),
+        ),
+    async execute(interaction) {
+        const subcommand = interaction.options.getSubcommand();
+
+        if (subcommand === 'two-pages') {
+            const pages = [
+                new EmbedBuilder().setTitle('Page 1').setDescription('This is the first page.').setColor(0x5865f2),
+                new EmbedBuilder().setTitle('Page 2').setDescription('This is the second page.').setColor(0x5865f2),
+            ];
+
+            return handlePagination(interaction, pages);
+        }
+        else if (subcommand === 'multiple-pages') {
+            const pages = [
+                new EmbedBuilder().setTitle('Page 1').setDescription('This is the first page.').setColor(0x5865f2),
+                new EmbedBuilder().setTitle('Page 2').setDescription('This is the second page.').setColor(0x5865f2),
+                new EmbedBuilder().setTitle('Page 3').setDescription('This is the third page.').setColor(0x5865f2),
+                new EmbedBuilder().setTitle('Page 4').setDescription('This is the fourth page.').setColor(0x5865f2),
+            ];
+
+            return handlePagination(interaction, pages);
+        }
+        else if (subcommand === 'too-many-pages') {
+            const pages = Array.from({ length: 10 }, (_, i) => (
+                new EmbedBuilder()
+                    .setTitle(`Page ${i + 1}`)
+                    .setDescription('This is the content of the page.')
+                    .setColor(0x5865f2)
+            ));
+
+            return handleAdvancedPagination(interaction, pages);
+        }
+    },
+};
+
+async function handlePagination(interaction, pages) {
+    let currentPage = 0;
+
+    const backButton = new ButtonBuilder()
+        .setCustomId('back-button')
+        .setLabel(emoji.arrow_left)
+        .setStyle(ButtonStyle.Primary)
+        .setDisabled(true);
+
+    const nextButton = new ButtonBuilder()
+        .setCustomId('next-button')
+        .setLabel(emoji.arrow_right)
+        .setStyle(ButtonStyle.Primary)
+        .setDisabled(pages.length === 1);
+
+    const buttonRow = new ActionRowBuilder().addComponents(
+        backButton,
+        nextButton,
+    );
+
+    const reply = await interaction.reply({
+        embeds: [pages[currentPage]],
+        components: [buttonRow],
+        ephemeral: true,
+    });
+
+    const collector = reply.createMessageComponentCollector({
+        componentType: ComponentType.Button,
+        filter: (i) => i.user.id === interaction.user.id,
+        time: 60_000,
+    });
+
+    collector.on('collect', async (i) => {
+        if (i.customId === 'back-button') currentPage--;
+        else if (i.customId === 'next-button') currentPage++;
+
+        backButton.setDisabled(currentPage === 0);
+        nextButton.setDisabled(currentPage === pages.length - 1);
+
+        await i.update({
+            embeds: [pages[currentPage]],
+            components: [buttonRow],
+        });
+    });
+
+    collector.on('end', async () => {
+        backButton.setDisabled(true);
+        nextButton.setDisabled(true);
+
+        await interaction.editReply({ components: [buttonRow] });
+    });
+}
+
+async function handleAdvancedPagination(interaction, pages) {
+    let currentPage = 0;
+
+    const firstPageButton = new ButtonBuilder()
+        .setCustomId('first-page-button')
+        .setLabel(emoji.arrow_up)
+        .setStyle(ButtonStyle.Primary)
+        .setDisabled(true);
+
+    const backButton = new ButtonBuilder()
+        .setCustomId('back-button')
+        .setLabel(emoji.arrow_left)
+        .setStyle(ButtonStyle.Primary)
+        .setDisabled(true);
+
+    const nextButton = new ButtonBuilder()
+        .setCustomId('next-button')
+        .setLabel(emoji.arrow_right)
+        .setStyle(ButtonStyle.Primary)
+        .setDisabled(pages.length <= 1);
+
+    const lastPageButton = new ButtonBuilder()
+        .setCustomId('last-page-button')
+        .setLabel(emoji.arrow_down)
+        .setStyle(ButtonStyle.Primary)
+        .setDisabled(pages.length <= 1);
+
+    const buttonRow = new ActionRowBuilder().addComponents(
+        firstPageButton,
+        backButton,
+        nextButton,
+        lastPageButton,
+    );
+
+    const reply = await interaction.reply({
+        embeds: [pages[currentPage]],
+        components: [buttonRow],
+        ephemeral: true,
+    });
+
+    const collector = reply.createMessageComponentCollector({
+        componentType: ComponentType.Button,
+        filter: (i) => i.user.id === interaction.user.id,
+        time: 120_000,
+    });
+
+    collector.on('collect', async (i) => {
+        if (i.customId === 'first-page-button') currentPage = 0;
+        if (i.customId === 'back-button') currentPage--;
+        if (i.customId === 'next-button') currentPage++;
+        if (i.customId === 'last-page-button') currentPage = pages.length - 1;
+
+        firstPageButton.setDisabled(currentPage === 0);
+        backButton.setDisabled(currentPage === 0);
+        nextButton.setDisabled(currentPage === pages.length - 1);
+        lastPageButton.setDisabled(currentPage === pages.length - 1);
+
+        await i.update({
+            embeds: [pages[currentPage]],
+            components: [buttonRow],
+        });
+    });
+
+    collector.on('end', async () => {
+        firstPageButton.setDisabled(true);
+        backButton.setDisabled(true);
+        nextButton.setDisabled(true);
+        lastPageButton.setDisabled(true);
+
+        await interaction.editReply({
+            components: [buttonRow],
+        });
+    });
+}

package/src/commands/utility/select-menus.js

@@ -0,0 +1,133 @@
+const {
+    SlashCommandBuilder,
+    ChannelSelectMenuBuilder,
+    ChannelType,
+    RoleSelectMenuBuilder,
+    StringSelectMenuBuilder,
+    StringSelectMenuOptionBuilder,
+    UserSelectMenuBuilder,
+    ActionRowBuilder,
+    ComponentType,
+} = require('discord.js');
+const emoji = require('./../../utils/emoji.js');
+
+module.exports = {
+    category: 'utility',
+    data: new SlashCommandBuilder()
+        .setName('select-menus')
+        .setDescription('Make a selection!')
+        .setDMPermission(false)
+        .addSubcommand(subcommand => subcommand
+            .setName('channel')
+            .setDescription('Example of a channel selection menu!'),
+        )
+        .addSubcommand(subcommand => subcommand
+            .setName('role')
+            .setDescription('Example of a role selection menu!'),
+        )
+        .addSubcommand(subcommand => subcommand
+            .setName('string')
+            .setDescription('Example of a string selection menu!'),
+        )
+        .addSubcommand(subcommand => subcommand
+            .setName('user')
+            .setDescription('Example of a user selection menu!'),
+        ),
+    async execute(interaction) {
+        const subcommand = interaction.options.getSubcommand();
+        const starters = [
+            {
+                label: 'Bulbasaur',
+                description: 'The dual-type Grass/Poison Seed Pokémon.',
+                value: 'bulbasaur',
+                emoji: emoji.herb,
+            },
+            {
+                label: 'Charmander',
+                description: 'The Fire-type Lizard Pokémon.',
+                value: 'charmander',
+                emoji: emoji.fire,
+            },
+            {
+                label: 'Squirtle',
+                description: 'The Water-type Tiny Turtle Pokémon.',
+                value: 'squirtle',
+                emoji: emoji.bubbles,
+            },
+        ];
+
+        if (subcommand === 'channel') {
+            const channelMenu = new ChannelSelectMenuBuilder()
+                .setCustomId(interaction.id)
+                .setMinValues(0)
+                .setMaxValues(1)
+                .setChannelTypes(ChannelType.GuildText);
+
+            await handleSelection(interaction, channelMenu, ComponentType.ChannelSelect);
+        }
+        else if (subcommand === 'role') {
+            const roleMenu = new RoleSelectMenuBuilder()
+                .setCustomId(interaction.id)
+                .setMinValues(0)
+                .setMaxValues(1);
+
+            await handleSelection(interaction, roleMenu, ComponentType.RoleSelect);
+        }
+        else if (subcommand === 'string') {
+            const stringMenu = new StringSelectMenuBuilder()
+                .setCustomId('starter')
+                .setPlaceholder('Make a selection!')
+                .setMinValues(0)
+                .setMaxValues(starters.length)
+                .addOptions(
+                    starters.map((starter) => new StringSelectMenuOptionBuilder()
+                        .setLabel(starter.label)
+                        .setDescription(starter.description)
+                        .setValue(starter.value)
+                        .setEmoji(starter.emoji),
+                    ),
+                );
+
+            await handleSelection(interaction, stringMenu, ComponentType.StringSelect);
+        }
+        else if (subcommand === 'user') {
+            const userMenu = new UserSelectMenuBuilder()
+                .setCustomId(interaction.id)
+                .setMinValues(0)
+                .setMaxValues(1);
+
+            await handleSelection(interaction, userMenu, ComponentType.UserSelect);
+        }
+    },
+};
+
+async function handleSelection(interaction, menu, componentType) {
+    const actionRow = new ActionRowBuilder().addComponents(menu);
+
+    const reply = await interaction.reply({
+        components: [actionRow],
+        ephemeral: true,
+    });
+
+    const collector = reply.createMessageComponentCollector({
+        componentType: componentType,
+        filter: (i) => i.user.id === interaction.user.id,
+        time: 60_000,
+    });
+
+    collector.on('collect', async (i) => {
+        await i.deferUpdate();
+        const selectedValues = i.values;
+
+        if (!selectedValues.length) {
+            await interaction.followUp({ content: 'You have emptied your selection.', ephemeral: true });
+        }
+        else {
+            await interaction.followUp({ content: `You have selected: ${selectedValues.join(', ')}`, ephemeral: true });
+        }
+    });
+
+    collector.on('end', async () => {
+        await interaction.editReply({ content: 'You ran out of time! Try again later...', components: [] });
+    });
+}

package/src/config.example.json

@@ -0,0 +1,5 @@
+{
+    "guildId": "",
+    "clientId": "",
+    "token": ""
+}