js-discord-modularcommand 1.1.0 → 2.0.1

package/dist/modularbutton.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Contains the structure for creating reusable button components.
+ * @author vicentefelipechile
+ * @license MIT
+ */
+import { ButtonBuilder, ButtonStyle } from "discord.js";
+import { ButtonExecuteFunction } from "./types";
+/**
+ * @class ModularButton
+ * @description A class to create and manage reusable button components.
+ */
+export default class ModularButton {
+    /** The Discord.js ButtonBuilder instance. */
+    buttonObject: ButtonBuilder;
+    /** The custom ID for the button, used to identify it in interactions. */
+    customId: string;
+    /** The visual style of the button. */
+    style: ButtonStyle;
+    /** The function to execute when the button is clicked. */
+    execute: ButtonExecuteFunction;
+    /**
+     * @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: string, style: ButtonStyle);
+    /**
+     * @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: ButtonExecuteFunction): this;
+}

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

@@ -1,133 +1,69 @@
 /**
- * @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
  */
-/**
- * Imports
- */
-import { ApplicationCommandOptionType, MessageComponentInteraction, ChatInputCommandInteraction, ModalSubmitInteraction, SlashCommandBuilder, ButtonBuilder, Locale, Message, ButtonStyle, Channel, User, Role, GuildMember, LocalizationMap, APIApplicationCommandOptionChoice } from 'discord.js';
+import { LocalizationMap, ButtonStyle, Locale } from 'discord.js';
 import ModularModal from './modularmodal.js';
-/**
- * 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 = (params: {
-    interaction: ChatInputCommandInteraction;
-}) => boolean | Promise<boolean>;
-/**
- * @description Registered Command as object to be used outside the modular command system.
- * @example
- * const PingCommand = new ModularCommand('ping');
- *
- * PingCommand.setExecute(({interaction}) => {
- *     interaction.reply('Pong!');
- * });
- *
- * const cmds = RegisterCommand([PingCommand])
- * const cmd = cmds[0];
- * console.log(cmd.execute); // [Function: execute]
- */
-type 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;
-};
-/**
- * Interface
- */
-/**
- * @description Represents a command option for a modular command.
- */
-interface CommandOption {
-    name: string;
-    type: ApplicationCommandOptionType;
-    description: Record<Locale, string> | string;
-    required?: boolean;
-    choices?: APIApplicationCommandOptionChoice[];
-}
-/**
- * @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;
-}
+import ModularButton from './modularbutton.js';
+import { ButtonExecuteFunction, CommandExecuteFunction, CommandOption, ComponentExecuteFunction, ModalExecuteFunction, PermissionCheckFunction } from './types.js';
 /**
  * @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
  * ]);
  */
-declare class ModularCommand {
+export default class ModularCommand {
+    /** The name of the command, must be unique. */
     name: string;
+    /** The main description of the command. */
     description: string;
-    execute: ExecuteFunction<ChatInputCommandInteraction>;
-    componentExecute?: ExecuteFunction<MessageComponentInteraction>;
-    modalExecute?: ModalExecuteFunction;
+    /** A map of localizations for the command's description. */
+    descriptionLocalizations?: LocalizationMap;
+    /** The options (arguments) that the command accepts. */
     options: CommandOption[];
+    /** An object containing localizations for the names and descriptions of the options. */
     optionsLocalizations: Record<string, Record<Locale, string>>;
-    customIdHandlers: Record<string, ExecuteFunction<ChatInputCommandInteraction>>;
+    /** The main function that executes when the command is invoked. */
+    execute: CommandExecuteFunction;
+    /** (Optional) The function to handle button interactions. */
+    buttonExecute?: ButtonExecuteFunction;
+    /** (Optional) The function to handle generic component interactions (like select menus). */
+    componentExecute?: ComponentExecuteFunction;
+    /** (Optional) The function to handle modal submissions. */
+    modalExecute?: ModalExecuteFunction;
+    /** A record of handlers for specific component custom IDs. */
+    customIdHandlers: Record<string, CommandExecuteFunction>;
+    /** The command's cooldown time in seconds. */
     cooldown: number;
-    modals: Map<string, ModularModal>;
-    buttons: Map<string, ModularButton>;
-    buttonsArray: ModularButton[];
+    /** Whether the command is marked as Not Safe For Work (NSFW). */
     isNSFW: boolean;
-    descriptionLocalizations?: LocalizationMap;
-    localizationPhrases?: Record<Locale, any>;
+    /** (Optional) An object with localized phrases to be used within the command's execution. */
+    localizationPhrases?: Record<Locale, string>;
+    /** (Optional) The function that checks if a user has permission to execute the command. */
     permissionCheck?: PermissionCheckFunction;
+    /** (Optional) The base ID for components associated with this command. */
     componentId?: string;
+    /** A map of modals associated with this command, keyed by modal ID. */
+    modals: Map<string, ModularModal>;
+    /** A map of buttons associated with this command, keyed by the button's custom ID. */
+    buttons: Map<string, ModularButton>;
+    /** An array containing all ModularButton instances for easy access. */
+    buttonsArray: ModularButton[];
     constructor(name: string);
     /**
      * Sets the description of the command.
@@ -137,32 +73,37 @@ declare class ModularCommand {
     setDescription(description: string): this;
     /**
      * 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: LocalizationMap): 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: 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;
+    setComponentExecute(componentId: string, executeFunction: ComponentExecuteFunction): 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.
      */
@@ -180,17 +121,17 @@ declare class ModularCommand {
     getComponentId(): string | undefined;
     /**
      * 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: 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.
+     * @param {CommandExecuteFunction} 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.
@@ -205,11 +146,3 @@ declare class ModularCommand {
      */
     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, };