js-discord-modularcommand 1.0.1 → 2.0.0

package/dist/modularbutton.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * @file Contains the structure for creating reusable button components.
+ * @author vicentefelipechile
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discord_js_1 = require("discord.js");
+// =================================================================================================
+// Main Class
+// =================================================================================================
+/**
+ * @class ModularButton
+ * @description A class to create and manage reusable button components.
+ */
+class ModularButton {
+    /**
+     * @description Creates a new ModularButton instance.
+     * @param {string} customId The custom ID for the button. This should be unique within the context of a message.
+     * @param {ButtonStyle} style The visual style of the button.
+     */
+    constructor(customId, style) {
+        /** The function to execute when the button is clicked. */
+        this.execute = async () => { };
+        this.buttonObject = new discord_js_1.ButtonBuilder()
+            .setCustomId(customId)
+            .setStyle(style);
+        this.customId = customId;
+        this.style = style;
+    }
+    /**
+     * @description Sets the execution function for the button's click event.
+     * @param {ButtonExecuteFunction} executeFunction The function to run when the button is interacted with.
+     * @returns {this} The current ModularButton instance for method chaining.
+     */
+    setExecute(executeFunction) {
+        this.execute = executeFunction;
+        return this;
+    }
+}
+exports.default = ModularButton;

package/dist/modularcommand.d.ts

@@ -6,170 +6,50 @@
 /**
  * Imports
  */
-import { ApplicationCommandOptionType, MessageComponentInteraction, ChatInputCommandInteraction, ModalSubmitInteraction, SlashCommandBuilder, TextInputBuilder, ButtonBuilder, ModalBuilder, Locale, Message, ButtonStyle, Channel, User, Role, GuildMember, LocalizationMap, APIApplicationCommandOptionChoice, TextInputStyle } from 'discord.js';
+import { LocalizationMap, ButtonStyle, Locale } from 'discord.js';
+import ModularModal from './modularmodal.js';
+import ModularButton from './modularbutton.js';
+import { ButtonExecuteFunction, CommandExecuteFunction, CommandOption, ComponentExecuteFunction, ModalExecuteFunction, PermissionCheckFunction } from './types.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.
+ * @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!');
+ * });
+ *
+ * PingCommand.setPermissionCheck(({ interaction }) => {
+ *     return interaction.member.permissions.has(PermissionFlagsBits.Administrator);
+ * });
+ *
+ * module.exports = RegisterCommand([
+ *     PingCommand
+ * ]);
  */
-declare class ModularCommand {
+export default class ModularCommand {
     name: string;
     description: string;
-    execute: ExecuteFunction<ChatInputCommandInteraction>;
-    componentExecute?: ExecuteFunction<MessageComponentInteraction>;
+    execute: CommandExecuteFunction;
+    buttonExecute?: ButtonExecuteFunction;
+    componentExecute?: ComponentExecuteFunction;
     modalExecute?: ModalExecuteFunction;
     options: CommandOption[];
     optionsLocalizations: Record<string, Record<Locale, string>>;
-    customIdHandlers: Record<string, ExecuteFunction<ChatInputCommandInteraction>>;
+    customIdHandlers: Record<string, CommandExecuteFunction>;
     cooldown: number;
     modals: Map<string, ModularModal>;
     buttons: Map<string, ModularButton>;
     buttonsArray: ModularButton[];
     isNSFW: boolean;
     descriptionLocalizations?: LocalizationMap;
-    localizationPhrases?: Record<Locale, any>;
+    localizationPhrases?: Record<Locale, string>;
     permissionCheck?: PermissionCheckFunction;
     componentId?: string;
-    constructor({ name, description, execute, componentExecute, modalExecute }: ModularCommandOptions);
+    constructor(name: string);
     /**
      * Sets the description of the command.
      * @param {string} description The description.
@@ -185,36 +65,23 @@ declare class ModularCommand {
     setLocalizationOptions(localizations: Record<string, Record<Locale, string>>): 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: Record<Locale, any>): this;
+    setLocalizationPhrases(localizationPhrases: Record<Locale, string>): this;
     /**
      * 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: ExecuteFunction<ChatInputCommandInteraction>): this;
+    setExecute(executeFunction: CommandExecuteFunction): 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.
+     * @param {ComponentExecuteFunction} 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;
+    setComponentExecute(componentId: string, executeFunction: ComponentExecuteFunction): this;
     /**
      * Set the minimun permissions required to execute the command.
      * @param {PermissionCheckFunction} permissionCheckFunction The function to check permissions.
@@ -241,16 +108,21 @@ declare class ModularCommand {
     /**
      * 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 {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;
+    addCustomIDHandler(customId: string, handlerFunction: CommandExecuteFunction): this;
+    /**
+     * Creates a new modal for the command.
+     * @param {string} modalId The ID for the modal.
+     * @returns {ModularModal} The created modal instance.
+     */
+    addModal(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.
+     */
+    addButton(customId: string, style: ButtonStyle): ModularButton;
 }
-/**
- * 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, };