js-discord-modularcommand 1.1.0 → 2.0.1

package/dist/modularcommand.js

@@ -1,81 +1,40 @@
 "use strict";
 /**
- * @module ModularCommand
- * @description A module for creating and managing modular commands in a easy way for me.
+ * @file Contains the main class for creating modular commands.
+ * @author vicentefelipechile
  * @license MIT
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModularButton = exports.ModularCommand = exports.RegisterCommand = void 0;
-/**
- * Imports
- */
+// =================================================================================================
+// Imports
+// =================================================================================================
 const discord_js_1 = require("discord.js");
-const locales_js_1 = require("./locales.js");
-const locales_js_2 = require("./locales.js");
 const modularmodal_js_1 = __importDefault(require("./modularmodal.js"));
-/**
- * Variables
- */
-const ALLOWED_OPTION_TYPE = [
-    discord_js_1.ApplicationCommandOptionType.String,
-    discord_js_1.ApplicationCommandOptionType.Boolean,
-    discord_js_1.ApplicationCommandOptionType.Integer,
-    discord_js_1.ApplicationCommandOptionType.Number,
-    discord_js_1.ApplicationCommandOptionType.User,
-    discord_js_1.ApplicationCommandOptionType.Channel,
-];
-const COOLDOWNS_MAP = new Map();
-/**
- * @class ModularButton
- * @description Represents a modular button that can be registered with Discord.js.
- * It allows for dynamic button creation and execution.
- */
-class ModularButton {
-    /**
-     * Creates a new button for the command.
-     * @param {string} customId The custom ID for the button.
-     * @param {ButtonStyle} style The style of the button.
-     */
-    constructor(customId, style) {
-        this.execute = async () => { };
-        this.buttonObject = new discord_js_1.ButtonBuilder();
-        this.buttonObject.setCustomId(customId);
-        this.buttonObject.setStyle(style);
-        this.customId = customId;
-        this.style = style;
-    }
-    /**
-     * Sets the execute function for the button.
-     * @param {ButtonExecuteFunction} executeFunction The function to execute.
-     * @return {ModularButton} The button instance for chaining.
-     */
-    setExecute(executeFunction) {
-        this.execute = executeFunction;
-        return this;
-    }
-}
-exports.ModularButton = ModularButton;
+const modularbutton_js_1 = __importDefault(require("./modularbutton.js"));
+// =================================================================================================
+// Class: ModularCommand
+// =================================================================================================
 /**
  * @description Represents a modular command that can be registered with Discord.js.
- * It allows for dynamic command creation and execution.
+ * It allows for dynamic command creation and execution in a simple way.
  * @example
  * const { ModularCommand, RegisterCommand } = require('js-discord-modularcommand');
  *
  * const PingCommand = new ModularCommand('ping');
  * PingCommand.setDescription('Sends a ping message.');
  * PingCommand.setExecute(async ({interaction}) => {
- *     await interaction.reply('Pong!');
+ *   await interaction.reply('Pong!');
  * });
  *
  * PingCommand.setPermissionCheck(({ interaction }) => {
- *     return interaction.member.permissions.has(PermissionFlagsBits.Administrator);
+ *   return interaction.member.permissions.has(PermissionFlagsBits.Administrator);
  * });
  *
  * module.exports = RegisterCommand([
- *     PingCommand
+ *   PingCommand
  * ]);
  */
 class ModularCommand {
@@ -105,7 +64,7 @@ class ModularCommand {
     }
     /**
      * Sets the description localizations for the command.
-     * @param {LocalizationMap} localizations The description localizations.
+     * @param {LocalizationMap} localizations The description localizations map.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setLocalizationsDescription(localizations) {
@@ -113,13 +72,18 @@ class ModularCommand {
         this.descriptionLocalizations = localizations;
         return this;
     }
+    /**
+     * Sets the localizations for the command's options.
+     * @param {Record<string, Record<Locale, string>>} localizations An object with the localizations.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
     setLocalizationOptions(localizations) {
         this.optionsLocalizations = localizations;
         return this;
     }
     /**
      * Sets the localization phrases for the command.
-     * @param {Record<Locale, any>} localizationPhrases The localization phrases.
+     * @param {Record<Locale, string>} localizationPhrases The localization phrases.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setLocalizationPhrases(localizationPhrases) {
@@ -128,7 +92,7 @@ class ModularCommand {
     }
     /**
      * Sets the execute function for the command.
-     * @param {ExecuteFunction<CommandInteraction>} executeFunction The function to execute.
+     * @param {CommandExecuteFunction} executeFunction The function to execute.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setExecute(executeFunction) {
@@ -138,7 +102,7 @@ class ModularCommand {
     /**
      * Sets the component execute function for the command.
      * @param {string} componentId The base ID for the components.
-     * @param {ExecuteFunction<MessageComponentInteraction>} executeFunction The function to execute for component interactions.
+     * @param {ComponentExecuteFunction} executeFunction The function to execute for component interactions.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setComponentExecute(componentId, executeFunction) {
@@ -147,7 +111,7 @@ class ModularCommand {
         return this;
     }
     /**
-     * Set the minimun permissions required to execute the command.
+     * Sets the minimum permissions required to execute the command.
      * @param {PermissionCheckFunction} permissionCheckFunction The function to check permissions.
      * @returns {ModularCommand} The command instance for chaining.
      */
@@ -173,20 +137,17 @@ class ModularCommand {
     }
     /**
      * Adds an option to the command.
-     * @param {CommandOption} option The option for the command option.
+     * @param {CommandOption} option The option for the command.
      * @returns {ModularCommand} The command instance for chaining.
      */
     addOption(option) {
-        if (!ALLOWED_OPTION_TYPE.includes(option.type)) {
-            throw new Error(`Invalid option type: ${option.type}. Allowed types are: ${ALLOWED_OPTION_TYPE.join(', ')}`);
-        }
         this.options.push(option);
         return this;
     }
     /**
      * Adds a custom ID handler for the command.
      * @param {string} customId The custom ID to match.
-     * @param {ExecuteFunction<CommandInteraction<CacheType>>} handlerFunction The function to execute when the custom ID matches.
+     * @param {CommandExecuteFunction} handlerFunction The function to execute when the custom ID matches.
      * @returns {ModularCommand} The command instance for chaining.
      */
     addCustomIDHandler(customId, handlerFunction) {
@@ -210,205 +171,10 @@ class ModularCommand {
      * @return {ModularButton} The created button instance.
      */
     addButton(customId, style) {
-        const button = new ModularButton(customId, style);
+        const button = new modularbutton_js_1.default(customId, style);
         this.buttons.set(customId, button);
         this.buttonsArray.push(button);
         return button;
     }
 }
-exports.ModularCommand = ModularCommand;
-/**
- * Registers an array of modular commands.
- * @param {ModularCommand[]} commands An array of ModularCommand instances.
- * @returns {RegisteredCommand[]} An array of command data objects ready for Discord.js client.
- */
-const RegisterCommand = (commands) => {
-    return commands.map(command => {
-        const commandBuilder = new discord_js_1.SlashCommandBuilder()
-            .setName(command.name)
-            .setDescription(command.description)
-            .setDescriptionLocalizations(command.descriptionLocalizations || null);
-        COOLDOWNS_MAP.set(command.name, new Map());
-        const options = {};
-        command.options.forEach(opt => {
-            const description = typeof opt.description === 'string' ?
-                opt.description :
-                (opt.description[discord_js_1.Locale.EnglishUS] || `The description for ${opt.name} in English.`);
-            const descriptionsLocalizations = typeof opt.description === 'object' ? opt.description : {};
-            if (!description) {
-                throw new Error(`Option '${opt.name}' is missing a description.`);
-            }
-            options[opt.name] = opt.type;
-            const optionBuilder = (option) => {
-                option.setName(opt.name)
-                    .setDescription(description)
-                    .setRequired(opt.required || false)
-                    .setDescriptionLocalizations(descriptionsLocalizations);
-                if (opt.choices && opt.choices.length > 0) {
-                    option.addChoices(...opt.choices);
-                }
-                return option;
-            };
-            switch (opt.type) {
-                case discord_js_1.ApplicationCommandOptionType.String:
-                    commandBuilder.addStringOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Boolean:
-                    commandBuilder.addBooleanOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Integer:
-                    commandBuilder.addIntegerOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Number:
-                    commandBuilder.addNumberOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.User:
-                    commandBuilder.addUserOption(optionBuilder);
-                    break;
-                case discord_js_1.ApplicationCommandOptionType.Channel:
-                    commandBuilder.addChannelOption(optionBuilder);
-                    break;
-                default:
-                    throw new Error(`Unsupported option type: ${opt.type}`);
-            }
-        });
-        const executeBuilder = async (interaction) => {
-            // User has permissions
-            if (command.permissionCheck && !command.permissionCheck({ interaction })) {
-                await interaction.reply({
-                    content: locales_js_1.LOCALE_FORBIDDEN[interaction.locale],
-                    flags: discord_js_1.MessageFlags.Ephemeral,
-                });
-                return;
-            }
-            // User is using a NSFW command in a non-NSFW channel
-            if (command.isNSFW && (!interaction.channel || !('nsfw' in interaction.channel) || !interaction.channel.nsfw)) {
-                await interaction.reply({
-                    content: locales_js_1.LOCALE_NSFW[interaction.locale],
-                    flags: discord_js_1.MessageFlags.Ephemeral,
-                });
-                return;
-            }
-            // User is in a cooldown
-            const lastTime = COOLDOWNS_MAP.get(command.name)?.get(interaction.user.id);
-            if (lastTime) {
-                const cooldownDuration = (Date.now() / 1000) - lastTime;
-                if (cooldownDuration < command.cooldown) {
-                    await interaction.reply({
-                        content: (0, locales_js_2.FormatSecondsLocale)(locales_js_1.LOCALE_DELAY[interaction.locale], command.cooldown - cooldownDuration),
-                        flags: discord_js_1.MessageFlags.Ephemeral,
-                    });
-                    return;
-                }
-                COOLDOWNS_MAP.get(command.name)?.set(interaction.user.id, Date.now() / 1000);
-            }
-            const args = {};
-            for (const option of Object.keys(options)) {
-                switch (options[option]) {
-                    case discord_js_1.ApplicationCommandOptionType.String:
-                        args[option] = interaction.options.getString(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Boolean:
-                        args[option] = interaction.options.getBoolean(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Integer:
-                        args[option] = interaction.options.getInteger(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Number:
-                        args[option] = interaction.options.getNumber(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.User:
-                        args[option] = interaction.options.getUser(option, false);
-                        break;
-                    case discord_js_1.ApplicationCommandOptionType.Channel:
-                        args[option] = interaction.options.getChannel(option, false);
-                        break;
-                    default:
-                        throw new Error(`Unsupported option type: ${options[option]}`);
-                }
-            }
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            const customId = interaction.customId;
-            if (customId && command.customIdHandlers[customId]) {
-                await command.customIdHandlers[customId]({
-                    interaction,
-                    args,
-                    command,
-                    locale: localeTable ? localeTable[localeTarget] : {},
-                });
-            }
-            else {
-                await command.execute({
-                    interaction,
-                    args,
-                    command,
-                    locale: localeTable ? localeTable[localeTarget] : {},
-                });
-            }
-        };
-        const componentExecuteBuilder = async (interaction) => {
-            if (!command.componentExecute)
-                return;
-            if (!interaction.customId.startsWith(command.getComponentId()))
-                return;
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            await command.componentExecute({
-                interaction,
-                command,
-                locale: localeTable ? localeTable[localeTarget] : {},
-            });
-        };
-        const modalExecuteBuilder = async (interaction) => {
-            const modalId = interaction.customId;
-            const modalObject = command.modals.get(modalId);
-            if (!modalObject)
-                return;
-            const args = {};
-            for (const [id] of modalObject.modalInputs.entries()) {
-                args[id] = interaction.fields.getTextInputValue(id);
-            }
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            await modalObject.execute({
-                interaction,
-                args,
-                command,
-                locale: localeTable ? localeTable[localeTarget] : {},
-            });
-        };
-        const buttonExecuteBuilder = async (interaction) => {
-            const buttonId = interaction.customId;
-            const buttonObject = command.buttons.get(buttonId);
-            if (!buttonObject)
-                return;
-            const localeTarget = (command.localizationPhrases && command.localizationPhrases[interaction.locale])
-                ? interaction.locale
-                : discord_js_1.Locale.EnglishUS;
-            const localeTable = command.localizationPhrases;
-            await buttonObject.execute({
-                interaction,
-                command,
-                locale: localeTable ? localeTable[localeTarget] : {},
-                message: interaction.message,
-            });
-        };
-        return {
-            data: commandBuilder,
-            execute: executeBuilder,
-            componentExecute: command.componentExecute ? componentExecuteBuilder : undefined,
-            modalExecute: command.modals.size > 0 ? modalExecuteBuilder : undefined,
-            buttonExecute: command.buttons.size > 0 ? buttonExecuteBuilder : undefined,
-            cooldown: command.cooldown,
-        };
-    });
-};
-exports.RegisterCommand = RegisterCommand;
 exports.default = ModularCommand;

package/dist/modularlocale.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @module ModularLocale
+ * @description Generic localization phrases used throughout the application.
+ * @license MIT
+ */
+import { Locale } from "discord.js";
+/**
+ * @description Class to handle localization in a modular way.
+ */
+declare class ModularLocale {
+    locale: Locale;
+    phrases: Record<string, string>;
+    seconds: Record<string, string>;
+    minutes: Record<string, string>;
+    constructor(locale: Locale);
+    /**
+     * Set the singular and plural forms for seconds.
+     * @param {string} singular The singular form (e.g., '{s} segundo').
+     * @param {string} plural The plural form (e.g., '{s} segundos').
+     * @returns {ModularLocale}
+     */
+    setSeconds(singular: string, plural: string): this;
+    /**
+     * Set the singular and plural forms for minutes.
+     * @param {string} singular The singular form (e.g., '{m} minuto').
+     * @param {string} plural The plural form (e.g., '{m} minutos').
+     * @returns {ModularLocale}
+     */
+    setMinutes(singular: string, plural: string): this;
+    /**
+     * Set the main phrase for the command delay.
+     * @param {string} phrase The phrase when only seconds or minutes are present.
+     * @returns {ModularLocale}
+     */
+    setPhrase(phrase: string): this;
+    /**
+     * Set the phrase when both seconds and minutes are present.
+     * @param {string} phrase The phrase for combined time.
+     * @returns {ModularLocale}
+     */
+    setPhrasePlural(phrase: string): this;
+    /**
+     * Set the phrase when only minutes are present.
+     * @param {string} phrase The phrase for when only minutes are present.
+     * @returns {ModularLocale}
+     */
+    setPhraseOnlyMinutes(phrase: string): this;
+    getPhrase: () => Record<string, string>;
+    getSeconds: () => Record<string, string>;
+    getMinutes: () => Record<string, string>;
+    /**
+     * Get the formatted phrase based on the time.
+     * @param {number} time The time in seconds.
+     * @returns {string} The formatted string.
+     */
+    formatTime(time: number): string;
+}
+/**
+ * @description Localization phrases for delay commands in ModularLocale structure.
+ * @example ```js
+ * const phrase = LOCALE_DELAY[Locale.EnglishUS];
+ * console.log( phrase.formatTime(64) );    // 'You must wait 4 seconds and 1 minute.'
+ * console.log( phrase.formatTime(390) );   // 'You must wait 30 seconds and 6 minutes.'
+ * console.log( phrase.formatTime(1) );     // 'You must wait 1 second.'
+ * console.log( phrase.formatTime(120) );   // 'You must wait 2 minutes.'
+ * ```
+ */
+declare const LOCALE_DELAY: {
+    "es-419": ModularLocale;
+    "en-US": ModularLocale;
+    "en-GB": ModularLocale;
+    "es-ES": ModularLocale;
+    "pt-BR": ModularLocale;
+    fr: ModularLocale;
+    de: ModularLocale;
+    it: ModularLocale;
+    ru: ModularLocale;
+    "zh-CN": ModularLocale;
+    "zh-TW": ModularLocale;
+    ja: ModularLocale;
+    ko: ModularLocale;
+    bg: ModularLocale;
+    cs: ModularLocale;
+    da: ModularLocale;
+    nl: ModularLocale;
+    fi: ModularLocale;
+    hu: ModularLocale;
+    no: ModularLocale;
+    pl: ModularLocale;
+    ro: ModularLocale;
+    "sv-SE": ModularLocale;
+    tr: ModularLocale;
+    uk: ModularLocale;
+    hi: ModularLocale;
+    id: ModularLocale;
+    el: ModularLocale;
+    hr: ModularLocale;
+    lt: ModularLocale;
+    th: ModularLocale;
+    vi: ModularLocale;
+};
+export default LOCALE_DELAY;
+export { LOCALE_DELAY, ModularLocale };