js-discord-modularcommand 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vicente
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/modularcommand.d.ts

@@ -0,0 +1,256 @@
+/**
+ * @module ModularCommand
+ * @description A module for creating and managing modular commands in a easy way for me.
+ * @license MIT
+ */
+/**
+ * Imports
+ */
+import { ApplicationCommandOptionType, MessageComponentInteraction, ChatInputCommandInteraction, ModalSubmitInteraction, SlashCommandBuilder, TextInputBuilder, ButtonBuilder, ModalBuilder, Locale, Message, ButtonStyle, Channel, User, Role, GuildMember, LocalizationMap, APIApplicationCommandOptionChoice, TextInputStyle } from 'discord.js';
+/**
+ * Localization Phrases
+ */
+/**
+ * @description Localization phrases for various commands.
+ * @example
+ * const example = LOCALE_FORBIDDEN[Locale.EnglishUS];
+ * console.log(example); // 'You do not have permission to use this command.'
+ */
+declare const LOCALE_FORBIDDEN: Record<Locale, string>;
+/**
+ * @description Localization phrases for NSFW commands.
+ * @example
+ * const example = LOCALE_NSFW[Locale.EnglishUS];
+ * console.log(example); // 'This command can only be used in NSFW channels.'
+ */
+declare const LOCALE_NSFW: Record<Locale, string>;
+/**
+ * @description Localization phrases for delay commands.
+ * @example
+ * const example = LOCALE_DELAY[Locale.EnglishUS];
+ * const secondsPluralRegEx = new RegExp('{plural\\|([^}]+)}', 'g');
+ * const seconds = 5;
+ * const formattedPhrase = example
+ *      .replace('{seconds}', seconds.toString())
+ *      .replace(secondsPluralRegEx, seconds === 1 ? '' : '$1');
+ *
+ * console.log(formattedPhrase); // 'You must wait 5 seconds before using this command again.'
+ */
+declare const LOCALE_DELAY: Record<Locale, string>;
+declare const LOCALE_ERROR: Record<Locale, string>;
+/**
+ * Types
+ */
+type ArgType = string | number | boolean | User | Channel | Role | GuildMember;
+type ExecuteFunction<T extends ChatInputCommandInteraction | MessageComponentInteraction> = (params: {
+    interaction: T;
+    args?: Record<string, ArgType>;
+    command: ModularCommand;
+    locale: Record<string, any>;
+}) => Promise<void>;
+type ButtonExecuteFunction = (params: {
+    interaction: MessageComponentInteraction;
+    command: ModularCommand;
+    locale: Record<string, any>;
+    message: Message;
+}) => Promise<void>;
+type ModalExecuteFunction = (params: {
+    interaction: ModalSubmitInteraction;
+    args: Record<string, string>;
+    command: ModularCommand;
+    locale: Record<string, any>;
+}) => Promise<void>;
+type PermissionCheckFunction = (interaction: ChatInputCommandInteraction) => boolean;
+/**
+ * Interface
+ */
+interface ModularCommandOptions {
+    name: string;
+    description?: string;
+    execute?: ExecuteFunction<ChatInputCommandInteraction>;
+    componentExecute?: ExecuteFunction<MessageComponentInteraction>;
+    modalExecute?: ModalExecuteFunction;
+}
+interface CommandOption {
+    name: string;
+    type: ApplicationCommandOptionType;
+    description: Record<Locale, string> | string;
+    required?: boolean;
+    choices?: APIApplicationCommandOptionChoice[];
+}
+interface RegisteredCommand {
+    data: SlashCommandBuilder;
+    execute: (interaction: ChatInputCommandInteraction) => Promise<void>;
+    componentExecute?: (interaction: MessageComponentInteraction) => Promise<void>;
+    modalExecute?: (interaction: ModalSubmitInteraction) => Promise<void>;
+    buttonExecute?: (interaction: MessageComponentInteraction) => Promise<void>;
+    cooldown: number;
+}
+/**
+ * @class ModularButton
+ * @description Represents a modular button that can be registered with Discord.js.
+ * It allows for dynamic button creation and execution.
+ */
+declare class ModularButton {
+    buttonObject: ButtonBuilder;
+    customId: string;
+    style: ButtonStyle;
+    execute: ButtonExecuteFunction;
+    /**
+     * 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: string, style: ButtonStyle);
+    /**
+     * Sets the execute function for the button.
+     * @param {ButtonExecuteFunction} executeFunction The function to execute.
+     * @return {ModularButton} The button instance for chaining.
+     */
+    setExecute(executeFunction: ButtonExecuteFunction): this;
+}
+/**
+ * @class ModularModal
+ * @description Represents a modular modal that can be registered with Discord.js.
+ * It allows for dynamic modal creation and execution.
+ */
+declare class ModularModal {
+    modalObject: ModalBuilder;
+    modalId: string;
+    modalInputs: Map<string, TextInputBuilder>;
+    command: ModularCommand;
+    execute: ModalExecuteFunction;
+    /**
+     * Creates a new modal for the command.
+     * @param {string} modalId The ID for the modal.
+     * @param {ModularCommand} command The command that this modal belongs to.
+     */
+    constructor(modalId: string, command: ModularCommand);
+    /**
+     * Sets the execute function for the modal.
+     * @param {ModalExecuteFunction} executeFunction The function to execute.
+     * @returns {ModularModal} The modal instance for chaining.
+     */
+    setExecute(executeFunction: ModalExecuteFunction): this;
+    /**
+     * Creates a new text input for the modal.
+     * @param {string} id The ID for the text input.
+     * @param {TextInputStyle} style The style of the text input.
+     * @returns {TextInputBuilder} The created text input instance.
+     */
+    newTextInput(id: string, style: TextInputStyle): TextInputBuilder;
+    /**
+     * Builds the modal object.
+     * @param {Record<string, any>} locale The localization object for the modal.
+     * @return {ModalBuilder} The built modal object.
+     */
+    build(locale: Record<string, any>): ModalBuilder;
+}
+/**
+ * @class ModularCommand
+ * @description Represents a modular command that can be registered with Discord.js.
+ * It allows for dynamic command creation and execution.
+ */
+declare class ModularCommand {
+    name: string;
+    description: string;
+    execute: ExecuteFunction<ChatInputCommandInteraction>;
+    componentExecute?: ExecuteFunction<MessageComponentInteraction>;
+    modalExecute?: ModalExecuteFunction;
+    options: CommandOption[];
+    optionsLocalizations: Record<string, Record<Locale, string>>;
+    customIdHandlers: Record<string, ExecuteFunction<ChatInputCommandInteraction>>;
+    cooldown: number;
+    modals: Map<string, ModularModal>;
+    buttons: Map<string, ModularButton>;
+    buttonsArray: ModularButton[];
+    isNSFW: boolean;
+    descriptionLocalizations?: LocalizationMap;
+    localizationPhrases?: Record<Locale, any>;
+    permissionCheck?: PermissionCheckFunction;
+    componentId?: string;
+    constructor({ name, description, execute, componentExecute, modalExecute }: ModularCommandOptions);
+    /**
+     * Sets the description of the command.
+     * @param {string} description The description.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setDescription(description: string): this;
+    /**
+     * Sets the description localizations for the command.
+     * @param {LocalizationMap} localizations The description localizations.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setLocalizationsDescription(localizations: LocalizationMap): this;
+    setLocalizationOptions(localizations: Record<string, Record<Locale, string>>): this;
+    /**
+     * Sets the localization phrases for the command.
+     * @param {Record<Locale, any>} localizationPhrases The localization phrases.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setLocalizationPhrases(localizationPhrases: Record<Locale, any>): this;
+    /**
+     * Sets the execute function for the command.
+     * @param {ExecuteFunction<CommandInteraction>} executeFunction The function to execute.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setExecute(executeFunction: ExecuteFunction<ChatInputCommandInteraction>): this;
+    /**
+     * 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.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setComponentExecute(componentId: string, executeFunction: ExecuteFunction<MessageComponentInteraction>): this;
+    /**
+     * Creates a new modal for the command.
+     * @param {string} modalId The ID for the modal.
+     * @returns {ModularModal} The created modal instance.
+     */
+    newModal(modalId: string): ModularModal;
+    /**
+     * Creates a new button for the command.
+     * @param {string} customId The custom ID for the button.
+     * @param {ButtonStyle} style The style of the button.
+     * @return {ModularButton} The created button instance.
+     */
+    newButton(customId: string, style: ButtonStyle): ModularButton;
+    /**
+     * Set the minimun permissions required to execute the command.
+     * @param {PermissionCheckFunction} permissionCheckFunction The function to check permissions.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setPermissionCheck(permissionCheckFunction: PermissionCheckFunction): this;
+    /**
+     * Sets the cooldown for the command.
+     * @param {number} cooldown The cooldown in seconds.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setCooldown(cooldown: number): this;
+    /**
+     * Gets the component ID for the command.
+     * @returns {string | undefined} The component ID.
+     */
+    getComponentId(): string | undefined;
+    /**
+     * Adds an option to the command.
+     * @param {CommandOption} option The option for the command option.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    addOption(option: CommandOption): 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.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    addCustomIDHandler(customId: string, handlerFunction: ExecuteFunction<ChatInputCommandInteraction>): this;
+}
+/**
+ * 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.
+ */
+declare const RegisterCommand: (commands: ModularCommand[]) => RegisteredCommand[];
+export default ModularCommand;
+export { RegisterCommand, ModularCommand, ModularButton, ModularModal, LOCALE_FORBIDDEN, LOCALE_DELAY, LOCALE_NSFW, LOCALE_ERROR, };

package/dist/modularcommand.js

@@ -0,0 +1,602 @@
+"use strict";
+/**
+ * @module ModularCommand
+ * @description A module for creating and managing modular commands in a easy way for me.
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCALE_ERROR = exports.LOCALE_NSFW = exports.LOCALE_DELAY = exports.LOCALE_FORBIDDEN = exports.ModularModal = exports.ModularButton = exports.ModularCommand = exports.RegisterCommand = void 0;
+/**
+ * Imports
+ */
+const discord_js_1 = require("discord.js");
+/**
+ * Localization Phrases
+ */
+/**
+ * @description Localization phrases for various commands.
+ * @example
+ * const example = LOCALE_FORBIDDEN[Locale.EnglishUS];
+ * console.log(example); // 'You do not have permission to use this command.'
+ */
+const LOCALE_FORBIDDEN = {
+    [discord_js_1.Locale.SpanishLATAM]: 'No tienes permiso para usar este comando.',
+    [discord_js_1.Locale.EnglishUS]: 'You do not have permission to use this command.',
+    [discord_js_1.Locale.EnglishGB]: 'I say, it appears you lack the proper authorisation to utilise this command, old bean.',
+    [discord_js_1.Locale.SpanishES]: 'Ostias chaval, tio parece que no vais a poder usar este comando madre mia willy, que barbaridad.',
+    [discord_js_1.Locale.PortugueseBR]: 'Você não tem permissão para usar este comando.',
+    [discord_js_1.Locale.French]: 'Vous n\'avez pas la permission d\'utiliser cette commande.',
+    [discord_js_1.Locale.German]: 'Du hast keine Berechtigung, diesen Befehl zu verwenden.',
+    [discord_js_1.Locale.Italian]: 'Non hai il permesso di usare questo comando.',
+    [discord_js_1.Locale.Russian]: 'У вас нет разрешения на использование этой команды.',
+    [discord_js_1.Locale.ChineseCN]: '您没有权限使用此命令。',
+    [discord_js_1.Locale.ChineseTW]: '您沒有權限使用此命令。',
+    [discord_js_1.Locale.Japanese]: 'このコマンドを使用する権限がありません。',
+    [discord_js_1.Locale.Korean]: '이 명령을 사용할 권한이 없습니다.',
+    [discord_js_1.Locale.Bulgarian]: 'Нямате разрешение да използвате тази команда.',
+    [discord_js_1.Locale.Czech]: 'Nemáte oprávnění k použití tohoto příkazu.',
+    [discord_js_1.Locale.Danish]: 'Du har ikke tilladelse til at bruge denne kommando.',
+    [discord_js_1.Locale.Dutch]: 'Je hebt geen toestemming om deze opdracht te gebruiken.',
+    [discord_js_1.Locale.Finnish]: 'Sinulla ei ole lupaa käyttää tätä komentoa.',
+    [discord_js_1.Locale.Hungarian]: 'Nincs jogosultságod ehhez a parancshoz.',
+    [discord_js_1.Locale.Norwegian]: 'Du har ikke tillatelse til å bruke denne kommandoen.',
+    [discord_js_1.Locale.Polish]: 'Nie masz uprawnień do używania tej komendy.',
+    [discord_js_1.Locale.Romanian]: 'Nu ai permisiunea de a folosi acest comandă.',
+    [discord_js_1.Locale.Swedish]: 'Du har inte behörighet att använda det här kommandot.',
+    [discord_js_1.Locale.Turkish]: 'Bu komutu kullanma izniniz yok.',
+    [discord_js_1.Locale.Ukrainian]: 'У вас немає дозволу на використання цієї команди.',
+    [discord_js_1.Locale.Hindi]: 'आपको इस कमांड का उपयोग करने की अनुमति नहीं है।',
+    [discord_js_1.Locale.Indonesian]: 'Anda tidak memiliki izin untuk menggunakan perintah ini.',
+    [discord_js_1.Locale.Greek]: 'Δεν έχετε άδεια να χρησιμοποιήσετε αυτήν την εντολή.',
+    [discord_js_1.Locale.Croatian]: 'Nemate dopuštenje za korištenje ove naredbe.',
+    [discord_js_1.Locale.Lithuanian]: 'Jūs neturite teisės naudoti šio komandos.',
+    [discord_js_1.Locale.Thai]: 'คุณไม่มีสิทธิ์ใช้คำสั่งนี้.',
+    [discord_js_1.Locale.Vietnamese]: 'Bạn không có quyền sử dụng lệnh này.'
+};
+exports.LOCALE_FORBIDDEN = LOCALE_FORBIDDEN;
+/**
+ * @description Localization phrases for NSFW commands.
+ * @example
+ * const example = LOCALE_NSFW[Locale.EnglishUS];
+ * console.log(example); // 'This command can only be used in NSFW channels.'
+ */
+const LOCALE_NSFW = {
+    [discord_js_1.Locale.SpanishLATAM]: 'Este comando solo puede ser usado en canales NSFW.',
+    [discord_js_1.Locale.EnglishUS]: 'This command can only be used in NSFW channels.',
+    [discord_js_1.Locale.EnglishGB]: 'I do declare, this command is exclusively for channels of a... risqué nature. little bit of cheeky fun, eh?',
+    [discord_js_1.Locale.SpanishES]: '¡Ostias, chaval! Que este comando es solo para los canales más guarros, ¿vale? No me seas meapilas.',
+    [discord_js_1.Locale.PortugueseBR]: 'Este comando só pode ser usado em canais NSFW.',
+    [discord_js_1.Locale.French]: 'Cette commande ne peut être utilisée que dans les salons NSFW.',
+    [discord_js_1.Locale.German]: 'Dieser Befehl kann nur in NSFW-Kanälen verwendet werden.',
+    [discord_js_1.Locale.Italian]: 'Questo comando può essere utilizzato solo nei canali NSFW.',
+    [discord_js_1.Locale.Russian]: 'Эту команду можно использовать только в каналах NSFW.',
+    [discord_js_1.Locale.ChineseCN]: '此命令只能在NSFW频道中使用。',
+    [discord_js_1.Locale.ChineseTW]: '此命令只能在 NSFW 頻道中使用。',
+    [discord_js_1.Locale.Japanese]: 'このコマンドはNSFWチャンネルでのみ使用できます。',
+    [discord_js_1.Locale.Korean]: '이 명령어는 NSFW 채널에서만 사용할 수 있습니다.',
+    [discord_js_1.Locale.Bulgarian]: 'Тази команда може да се използва само в NSFW канали.',
+    [discord_js_1.Locale.Czech]: 'Tento příkaz lze použít pouze v kanálech NSFW.',
+    [discord_js_1.Locale.Danish]: 'Denne kommando kan kun bruges i NSFW-kanaler.',
+    [discord_js_1.Locale.Dutch]: 'Deze opdracht kan alleen worden gebruikt in NSFW-kanalen.',
+    [discord_js_1.Locale.Finnish]: 'Tätä komentoa voi käyttää vain NSFW-kanavilla.',
+    [discord_js_1.Locale.Hungarian]: 'Ez a parancs csak NSFW csatornákon használható.',
+    [discord_js_1.Locale.Norwegian]: 'Denne kommandoen kan bare brukes i NSFW-kanaler.',
+    [discord_js_1.Locale.Polish]: 'Ta komenda może być używana tylko na kanałach NSFW.',
+    [discord_js_1.Locale.Romanian]: 'Această comandă poate fi utilizată numai în canalele NSFW.',
+    [discord_js_1.Locale.Swedish]: 'Det här kommandot kan endast användas i NSFW-kanaler.',
+    [discord_js_1.Locale.Turkish]: 'Bu komut yalnızca NSFW kanallarında kullanılabilir.',
+    [discord_js_1.Locale.Ukrainian]: 'Цю команду можна використовувати лише в каналах NSFW.',
+    [discord_js_1.Locale.Hindi]: 'यह कमांड केवल NSFW चैनलों में ही उपयोग की जा सकती है।',
+    [discord_js_1.Locale.Indonesian]: 'Perintah ini hanya dapat digunakan di saluran NSFW.',
+    [discord_js_1.Locale.Greek]: 'Αυτή η εντολή μπορεί να χρησιμοποιηθεί μόνο σε κανάλια NSFW.',
+    [discord_js_1.Locale.Croatian]: 'Ova se naredba može koristiti samo u NSFW kanalima.',
+    [discord_js_1.Locale.Lithuanian]: 'Ši komanda gali būti naudojama tik NSFW kanaluose.',
+    [discord_js_1.Locale.Thai]: 'คำสั่งนี้สามารถใช้ได้เฉพาะในช่องทาง NSFW เท่านั้น.',
+    [discord_js_1.Locale.Vietnamese]: 'Lệnh này chỉ có thể được sử dụng trong các kênh NSFW.'
+};
+exports.LOCALE_NSFW = LOCALE_NSFW;
+/**
+ * @description Localization phrases for delay commands.
+ * @example
+ * const example = LOCALE_DELAY[Locale.EnglishUS];
+ * const secondsPluralRegEx = new RegExp('{plural\\|([^}]+)}', 'g');
+ * const seconds = 5;
+ * const formattedPhrase = example
+ *      .replace('{seconds}', seconds.toString())
+ *      .replace(secondsPluralRegEx, seconds === 1 ? '' : '$1');
+ *
+ * console.log(formattedPhrase); // 'You must wait 5 seconds before using this command again.'
+ */
+const LOCALE_DELAY = {
+    [discord_js_1.Locale.SpanishLATAM]: 'Debes esperar {seconds} segundo{plural|s} antes de utilizar este comando denuevo.',
+    [discord_js_1.Locale.EnglishUS]: 'You must wait {seconds} second{plural|s} before using this command again.',
+    [discord_js_1.Locale.EnglishGB]: 'I do declare, you must wait {seconds} second{plural|s} before using this command again.',
+    [discord_js_1.Locale.SpanishES]: '¡Ostias, chaval! Debes esperar {seconds} segundo{plural|s} antes de utilizar este comando denuevo.',
+    [discord_js_1.Locale.PortugueseBR]: 'Você deve esperar {seconds} segundo{plural|s} antes de usar este comando novamente.',
+    [discord_js_1.Locale.French]: 'Vous devez attendre {seconds} seconde{plural|s} avant d\'utiliser cette commande à nouveau.',
+    [discord_js_1.Locale.German]: 'Sie müssen {seconds} Sekunde{plural|n} warten, bevor Sie diesen Befehl erneut verwenden können.',
+    [discord_js_1.Locale.Italian]: 'Devi aspettare {seconds} secondo{plural|i} prima di utilizzare di nuovo questo comando.',
+    [discord_js_1.Locale.Russian]: 'Вы должны подождать {seconds} секунду{plural|ы} перед повторным использованием этой команды.',
+    [discord_js_1.Locale.ChineseCN]: '您必须等待 {seconds} 秒钟{plural|s}才能再次使用此命令。',
+    [discord_js_1.Locale.ChineseTW]: '您必須等待 {seconds} 秒鐘{plural|s}才能再次使用此命令。',
+    [discord_js_1.Locale.Japanese]: 'このコマンドを再度使用するには、{seconds} 秒待つ必要があります。',
+    [discord_js_1.Locale.Korean]: '이 명령어를 다시 사용하려면 {seconds} 초 기다려야 합니다.',
+    [discord_js_1.Locale.Bulgarian]: 'Трябва да изчакате {seconds} секунда{plural|и}, преди да използвате тази команда отново.',
+    [discord_js_1.Locale.Czech]: 'Musíte počkat {seconds} sekundu{plural|y}, než znovu použijete tento příkaz.',
+    [discord_js_1.Locale.Danish]: 'Du skal vente {seconds} sekund{plural|er} før du kan bruge denne kommando igen.',
+    [discord_js_1.Locale.Dutch]: 'Je moet {seconds} seconde{plural|n} wachten voordat je dit commando opnieuw kunt gebruiken.',
+    [discord_js_1.Locale.Finnish]: 'Sinun on odotettava {seconds} sekuntia ennen kuin voit käyttää tätä komentoa uudelleen.',
+    [discord_js_1.Locale.Hungarian]: 'Várnod kell {seconds} másodpercet, mielőtt újra használhatod ezt a parancsot.',
+    [discord_js_1.Locale.Norwegian]: 'Du må vente {seconds} sekund{plural|er} før du kan bruke denne kommandoen igjen.',
+    [discord_js_1.Locale.Polish]: 'Musisz poczekać {seconds} sekund{plural|y}, zanim ponownie użyjesz tego polecenia.',
+    [discord_js_1.Locale.Romanian]: 'Trebuie să aștepți {seconds} secundă{plural|e} înainte de a folosi din nou acest comandă.',
+    [discord_js_1.Locale.Swedish]: 'Du måste vänta {seconds} sekund{plural|er} innan du kan använda det här kommandot igen.',
+    [discord_js_1.Locale.Turkish]: 'Bu komutu tekrar kullanmadan önce {seconds} saniye beklemelisiniz.',
+    [discord_js_1.Locale.Ukrainian]: 'Вам потрібно почекати {seconds} секунду{plural|и}, перш ніж знову використовувати цю команду.',
+    [discord_js_1.Locale.Hindi]: 'आपको इस कमांड का उपयोग करने से पहले {seconds} सेकंड{plural|s} इंतजार करना होगा।',
+    [discord_js_1.Locale.Indonesian]: 'Anda harus menunggu {seconds} detik{plural|s} sebelum menggunakan perintah ini lagi.',
+    [discord_js_1.Locale.Greek]: 'Πρέπει να περιμένετε {seconds} δευτερόλεπτο{plural|α} πριν χρησιμοποιήσετε ξανά αυτήν την εντολή.',
+    [discord_js_1.Locale.Croatian]: 'Morate pričekati {seconds} sekundu{plural|e} prije nego što ponovno upotrijebite ovu naredbu.',
+    [discord_js_1.Locale.Lithuanian]: 'Prieš vėl naudodamiesi šiuo komandu, turite palaukti {seconds} sekundę{plural|es}.',
+    [discord_js_1.Locale.Thai]: 'คุณต้องรอ {seconds} วินาที{plural|s} ก่อนที่จะใช้คำสั่งนี้อีกครั้ง',
+    [discord_js_1.Locale.Vietnamese]: 'Bạn phải đợi {seconds} giây{plural|s} trước khi sử dụng lại lệnh này.'
+};
+exports.LOCALE_DELAY = LOCALE_DELAY;
+const LOCALE_ERROR = {
+    [discord_js_1.Locale.SpanishLATAM]: 'Ocurrió un error al procesar tu solicitud.',
+    [discord_js_1.Locale.EnglishUS]: 'An error occurred while processing your request.',
+    [discord_js_1.Locale.EnglishGB]: 'I do declare, an error occurred while processing your request.',
+    [discord_js_1.Locale.SpanishES]: 'Pero que me estás contando, willy, ocurrió un error al procesar tu solicitud.',
+    [discord_js_1.Locale.PortugueseBR]: 'Ocorreu um erro ao processar sua solicitação.',
+    [discord_js_1.Locale.French]: 'Une erreur est survenue lors du traitement de votre demande.',
+    [discord_js_1.Locale.German]: 'Bei der Verarbeitung Ihrer Anfrage ist ein Fehler aufgetreten.',
+    [discord_js_1.Locale.Italian]: 'Si è verificato un errore durante l\'elaborazione della tua richiesta.',
+    [discord_js_1.Locale.Russian]: 'Произошла ошибка при обработке вашего запроса.',
+    [discord_js_1.Locale.ChineseCN]: '处理您的请求时发生错误。',
+    [discord_js_1.Locale.ChineseTW]: '處理您的請求時發生錯誤。',
+    [discord_js_1.Locale.Japanese]: 'リクエストの処理中にエラーが発生しました。',
+    [discord_js_1.Locale.Korean]: '요청을 처리하는 동안 오류가 발생했습니다.',
+    [discord_js_1.Locale.Bulgarian]: 'При обработката на заявката ви възникна грешка.',
+    [discord_js_1.Locale.Czech]: 'Při zpracování vaší žádosti došlo k chybě.',
+    [discord_js_1.Locale.Danish]: 'Der opstod en fejl under behandlingen af din anmodning.',
+    [discord_js_1.Locale.Dutch]: 'Er is een fout opgetreden bij het verwerken van uw verzoek.',
+    [discord_js_1.Locale.Finnish]: 'Pyyntösi käsittelyssä tapahtui virhe.',
+    [discord_js_1.Locale.Hungarian]: 'A kérésed feldolgozása során hiba lépett fel.',
+    [discord_js_1.Locale.Norwegian]: 'Det oppstod en feil under behandling av forespørselen din.',
+    [discord_js_1.Locale.Polish]: 'Wystąpił błąd podczas przetwarzania twojej prośby.',
+    [discord_js_1.Locale.Romanian]: 'A apărut o eroare în timpul procesării cererii tale.',
+    [discord_js_1.Locale.Swedish]: 'Ett fel inträffade vid behandling av din begäran.',
+    [discord_js_1.Locale.Turkish]: 'Talebiniz işlenirken bir hata oluştu.',
+    [discord_js_1.Locale.Ukrainian]: 'Під час обробки вашого запиту сталася помилка.',
+    [discord_js_1.Locale.Hindi]: 'आपके अनुरोध को संसाधित करते समय एक त्रुटि हुई।',
+    [discord_js_1.Locale.Indonesian]: 'Terjadi kesalahan saat memproses permintaan Anda.',
+    [discord_js_1.Locale.Greek]: 'Συνέβη σφάλμα κατά την επεξεργασία του αιτήματός σας.',
+    [discord_js_1.Locale.Croatian]: 'Došlo je do pogreške prilikom obrade vašeg zahtjeva.',
+    [discord_js_1.Locale.Lithuanian]: 'Apdorojant jūsų užklausą įvyko klaida.',
+    [discord_js_1.Locale.Thai]: 'เกิดข้อผิดพลาดระหว่างการประมวลผลคำขอของคุณ',
+    [discord_js_1.Locale.Vietnamese]: 'Đã xảy ra lỗi trong quá trình xử lý yêu cầu của bạn.'
+};
+exports.LOCALE_ERROR = LOCALE_ERROR;
+/**
+ * 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,
+];
+/**
+ * @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;
+/**
+ * @class ModularModal
+ * @description Represents a modular modal that can be registered with Discord.js.
+ * It allows for dynamic modal creation and execution.
+ */
+class ModularModal {
+    /**
+     * Creates a new modal for the command.
+     * @param {string} modalId The ID for the modal.
+     * @param {ModularCommand} command The command that this modal belongs to.
+     */
+    constructor(modalId, command) {
+        this.execute = async () => { };
+        this.modalObject = new discord_js_1.ModalBuilder();
+        this.modalObject.setCustomId(modalId);
+        this.modalId = modalId;
+        this.modalInputs = new Map();
+        this.command = command;
+    }
+    /**
+     * Sets the execute function for the modal.
+     * @param {ModalExecuteFunction} executeFunction The function to execute.
+     * @returns {ModularModal} The modal instance for chaining.
+     */
+    setExecute(executeFunction) {
+        this.execute = executeFunction;
+        return this;
+    }
+    /**
+     * Creates a new text input for the modal.
+     * @param {string} id The ID for the text input.
+     * @param {TextInputStyle} style The style of the text input.
+     * @returns {TextInputBuilder} The created text input instance.
+     */
+    newTextInput(id, style) {
+        const textInput = new discord_js_1.TextInputBuilder();
+        textInput.setCustomId(id);
+        textInput.setStyle(style);
+        this.modalInputs.set(id, textInput);
+        this.modalObject.addComponents(new discord_js_1.ActionRowBuilder().addComponents(textInput));
+        return textInput;
+    }
+    /**
+     * Builds the modal object.
+     * @param {Record<string, any>} locale The localization object for the modal.
+     * @return {ModalBuilder} The built modal object.
+     */
+    build(locale) {
+        const selfModal = this.modalObject;
+        const commandName = this.command.name;
+        selfModal.setTitle(locale[`${commandName}.${this.modalId}.title`]);
+        this.modalInputs.forEach((input, id) => {
+            input.setLabel(locale[`${commandName}.${id}.label`]);
+            input.setPlaceholder(locale[`${commandName}.${id}.placeholder`]);
+        });
+        return selfModal;
+    }
+}
+exports.ModularModal = ModularModal;
+/**
+ * @class ModularCommand
+ * @description Represents a modular command that can be registered with Discord.js.
+ * It allows for dynamic command creation and execution.
+ */
+class ModularCommand {
+    constructor({ name, description, execute, componentExecute, modalExecute }) {
+        this.name = name;
+        this.description = description || '';
+        this.execute = execute || (async () => { });
+        this.componentExecute = componentExecute;
+        this.modalExecute = modalExecute;
+        this.options = [];
+        this.optionsLocalizations = {};
+        this.customIdHandlers = {};
+        this.cooldown = 3;
+        this.modals = new Map();
+        this.buttons = new Map();
+        this.buttonsArray = [];
+        this.isNSFW = false;
+    }
+    /**
+     * Sets the description of the command.
+     * @param {string} description The description.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setDescription(description) {
+        this.description = description;
+        return this;
+    }
+    /**
+     * Sets the description localizations for the command.
+     * @param {LocalizationMap} localizations The description localizations.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setLocalizationsDescription(localizations) {
+        this.description = localizations[discord_js_1.Locale.EnglishUS] || this.description;
+        this.descriptionLocalizations = localizations;
+        return this;
+    }
+    setLocalizationOptions(localizations) {
+        this.optionsLocalizations = localizations;
+        return this;
+    }
+    /**
+     * Sets the localization phrases for the command.
+     * @param {Record<Locale, any>} localizationPhrases The localization phrases.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setLocalizationPhrases(localizationPhrases) {
+        this.localizationPhrases = localizationPhrases;
+        return this;
+    }
+    /**
+     * Sets the execute function for the command.
+     * @param {ExecuteFunction<CommandInteraction>} executeFunction The function to execute.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setExecute(executeFunction) {
+        this.execute = executeFunction;
+        return this;
+    }
+    /**
+     * 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.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setComponentExecute(componentId, executeFunction) {
+        this.componentId = componentId;
+        this.componentExecute = executeFunction;
+        return this;
+    }
+    /**
+     * Creates a new modal for the command.
+     * @param {string} modalId The ID for the modal.
+     * @returns {ModularModal} The created modal instance.
+     */
+    newModal(modalId) {
+        const modal = new ModularModal(modalId, this);
+        this.modals.set(modalId, modal);
+        return modal;
+    }
+    /**
+     * Creates a new button for the command.
+     * @param {string} customId The custom ID for the button.
+     * @param {ButtonStyle} style The style of the button.
+     * @return {ModularButton} The created button instance.
+     */
+    newButton(customId, style) {
+        const button = new ModularButton(customId, style);
+        this.buttons.set(customId, button);
+        this.buttonsArray.push(button);
+        return button;
+    }
+    /**
+     * Set the minimun permissions required to execute the command.
+     * @param {PermissionCheckFunction} permissionCheckFunction The function to check permissions.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setPermissionCheck(permissionCheckFunction) {
+        this.permissionCheck = permissionCheckFunction;
+        return this;
+    }
+    /**
+     * Sets the cooldown for the command.
+     * @param {number} cooldown The cooldown in seconds.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setCooldown(cooldown) {
+        this.cooldown = cooldown;
+        return this;
+    }
+    /**
+     * Gets the component ID for the command.
+     * @returns {string | undefined} The component ID.
+     */
+    getComponentId() {
+        return this.componentId;
+    }
+    /**
+     * Adds an option to the command.
+     * @param {CommandOption} option The option for the command option.
+     * @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.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    addCustomIDHandler(customId, handlerFunction) {
+        this.customIdHandlers[customId] = handlerFunction;
+        return this;
+    }
+}
+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);
+        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) => {
+            if (command.permissionCheck && !command.permissionCheck(interaction)) {
+                await interaction.reply({
+                    content: LOCALE_FORBIDDEN[interaction.locale] || LOCALE_FORBIDDEN[discord_js_1.Locale.EnglishUS],
+                    flags: discord_js_1.MessageFlags.Ephemeral,
+                });
+                return;
+            }
+            if (command.isNSFW && (!interaction.channel || !('nsfw' in interaction.channel) || !interaction.channel.nsfw)) {
+                await interaction.reply({
+                    content: LOCALE_NSFW[interaction.locale] || LOCALE_NSFW[discord_js_1.Locale.EnglishUS],
+                    flags: discord_js_1.MessageFlags.Ephemeral,
+                });
+                return;
+            }
+            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/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "js-discord-modularcommand",
+  "version": "1.0.0",
+  "description": "",
+  "keywords": [ "discord", "js", "node" ],
+  "license": "MIT",
+  "author": "SummerTYT",
+  "type": "commonjs",
+  "types": "./dist/index.d.ts",
+  "files": [ "dist/**/*" ],
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepublish": "npm run build"
+  },
+  "dependencies": {
+    "discord.js": "^14.21.0",
+    "typescript": "^5.9.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.2.1"
+  }
+}