js-discord-modularcommand 2.0.3 → 2.2.0

package/README.md

@@ -6,17 +6,12 @@ A module to create and manage modular commands in a simple way for Discord.js bo
 
 This library simplifies the creation and management of slash commands for [Discord.js](https://discord.js.org/). It allows you to structure your commands in a modular way, making it easier to handle logic, permissions, cooldowns, localizations, and interactive components like buttons and modals.
 
-The main classes are:
-- [`ModularCommand`](src/modularcommand.ts): To define the base structure of a command.
-- [`ModularButton`](src/modularcommand.ts): To create interactive buttons associated with a command.
-- [`ModularModal`](src/modularcommand.ts): To create modals (forms) that the user can fill out.
-
 ## How to use it?
 
 First, install the package in your project:
 
 ```sh
-npm install js-discord-modularcommand
+npm install js-discord-modularcommand@latest
 ```
 
 Then, you can create your commands in a modular fashion. Here is a basic example of a `ping` command:
@@ -24,7 +19,7 @@ Then, you can create your commands in a modular fashion. Here is a basic example
 ```javascript
 // filepath: commands/ping.js
 const { ModularCommand, RegisterCommand } = require('js-discord-modularcommand');
-const { PermissionFlagsBits } = require('discord.js');
+const { PermissionFlagsBits, Locale } = require('discord.js');
 
 // Create a new command instance
 const PingCommand = new ModularCommand('ping');
@@ -37,15 +32,31 @@ PingCommand.setPermissionCheck(async ({ interaction }) => {
     return interaction.member.permissions.has(PermissionFlagsBits.Administrator);
 });
 
-// Define the logic to be executed
-PingCommand.setExecute(async ({ interaction }) => {
-    await interaction.reply('Pong!');
+// Optional: Localization to use with 'locale'
+pong.setLocalizationPhrases({
+    [Locale.EnglishUS]: {
+        response: 'Replies with Pong!',
+    },
+    [Locale.SpanishLATAM]: {
+        response: 'Responde con Pong!',
+    }
+});
+
+// Set the command's description
+pong.setDescription('Replies with Pong!');
+
+// Optional: Add more localization descriptions for the command itself
+pong.setLocalizationDescription({
+    [Locale.EnglishUS]: 'Replies with Pong!',
+    [Locale.SpanishLATAM]: 'Responde con Pong!',
+});
+
+// Set the executor function
+pong.setExecute(async ({ interaction, locale }) => {
+    await interaction.reply(locale['response']);
 });
 
-// Register the command so it can be used by the Discord.js client
-module.exports = RegisterCommand([
-    PingCommand
-]);
+module.exports = RegisterCommand(pong)
 ```
 
 In your main file, you can load the commands and register their executors with your Discord client.

package/dist/modularcommand.d.ts

@@ -3,7 +3,7 @@
  * @author vicentefelipechile
  * @license MIT
  */
-import { LocalizationMap, ButtonStyle, Locale } from 'discord.js';
+import { LocalizationMap, ButtonStyle } from 'discord.js';
 import ModularModal from './modularmodal.js';
 import ModularButton from './modularbutton.js';
 import { ButtonExecuteFunction, CommandExecuteFunction, CommandOption, ComponentExecuteFunction, ModalExecuteFunction, PermissionCheckFunction } from './types.js';
@@ -37,7 +37,7 @@ export default class ModularCommand {
     /** 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>>;
+    optionsLocalizations: LocalizationMap;
     /** The main function that executes when the command is invoked. */
     execute: CommandExecuteFunction;
     /** (Optional) The function to handle button interactions. */
@@ -53,7 +53,7 @@ export default class ModularCommand {
     /** Whether the command is marked as Not Safe For Work (NSFW). */
     isNSFW: boolean;
     /** (Optional) An object with localized phrases to be used within the command's execution. */
-    localizationPhrases?: Record<Locale, string>;
+    localizationPhrases?: LocalizationMap;
     /** (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. */
@@ -72,23 +72,31 @@ export default class ModularCommand {
      */
     setDescription(description: string): this;
     /**
+     * @deprecated Use setLocalizationDescription instead.
      * Sets the description localizations for the command.
      * @param {LocalizationMap} localizations The description localizations map.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setLocalizationsDescription(localizations: LocalizationMap): this;
+    /**
+     * Sets the description localizations for the command.
+     * @param {LocalizationMap} localizations The description localizations map.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setLocalizationDescription(localizations: LocalizationMap): this;
     /**
      * Sets the localizations for the command's options.
-     * @param {Record<string, Record<Locale, string>>} localizations An object with the localizations.
+     * @param {LocalizationMap} localizations An object with the localizations.
      * @returns {ModularCommand} The command instance for chaining.
      */
-    setLocalizationOptions(localizations: Record<string, Record<Locale, string>>): this;
+    setLocalizationOptions(localizations: LocalizationMap): this;
     /**
      * Sets the localization phrases for the command.
-     * @param {Record<Locale, string>} localizationPhrases The localization phrases.
+     * Accepts a partial record, so not all locales need to be provided.
+     * @param {LocalizationMap} localizationPhrases The localization phrases.
      * @returns {ModularCommand} The command instance for chaining.
      */
-    setLocalizationPhrases(localizationPhrases: Record<Locale, string>): this;
+    setLocalizationPhrases(localizationPhrases: LocalizationMap): this;
     /**
      * Sets the execute function for the command.
      * @param {CommandExecuteFunction} executeFunction The function to execute.

package/dist/modularcommand.js

@@ -63,31 +63,50 @@ class ModularCommand {
         return this;
     }
     /**
+     * @deprecated Use setLocalizationDescription instead.
      * Sets the description localizations for the command.
      * @param {LocalizationMap} localizations The description localizations map.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setLocalizationsDescription(localizations) {
+        return this.setLocalizationDescription(localizations);
+    }
+    /**
+     * Sets the description localizations for the command.
+     * @param {LocalizationMap} localizations The description localizations map.
+     * @returns {ModularCommand} The command instance for chaining.
+     */
+    setLocalizationDescription(localizations) {
         this.description = localizations[discord_js_1.Locale.EnglishUS] || this.description;
-        this.descriptionLocalizations = localizations;
+        this.descriptionLocalizations = {
+            ...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.
+     * @param {LocalizationMap} localizations An object with the localizations.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setLocalizationOptions(localizations) {
-        this.optionsLocalizations = localizations;
+        this.optionsLocalizations = {
+            ...this.optionsLocalizations,
+            ...localizations,
+        };
         return this;
     }
     /**
      * Sets the localization phrases for the command.
-     * @param {Record<Locale, string>} localizationPhrases The localization phrases.
+     * Accepts a partial record, so not all locales need to be provided.
+     * @param {LocalizationMap} localizationPhrases The localization phrases.
      * @returns {ModularCommand} The command instance for chaining.
      */
     setLocalizationPhrases(localizationPhrases) {
-        this.localizationPhrases = localizationPhrases;
+        this.localizationPhrases = {
+            ...this.localizationPhrases,
+            ...localizationPhrases,
+        };
         return this;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-discord-modularcommand",
-  "version": "2.0.3",
+  "version": "2.2.0",
   "description": "",
   "keywords": [
     "discord",