reciple 1.6.1 → 1.6.2

package/bin/reciple/classes/Config.d.ts

@@ -10,6 +10,7 @@ export interface Config {
         messageCommand: {
             enabled: boolean;
             replyOnError: boolean;
+            allowCommandAlias: boolean;
             commandArgumentSeparator: string;
         };
         interactionCommand: {

package/bin/reciple/classes/RecipleClient.js

@@ -123,17 +123,19 @@ class RecipleClient extends discord_js_1.Client {
         return this;
     }
     messageCommandExecute(message, prefix) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!message.content || !this.isReady())
                 return;
             const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
-            if (!(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command) || !parseCommand)
+            if (!parseCommand || !(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command))
                 return;
-            const command = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()];
+            const command = (_a = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()]) !== null && _a !== void 0 ? _a : (this.config.commands.messageCommand.allowCommandAlias
+                ? Object.values(this.commands.MESSAGE_COMMANDS).find(c => c.aliases.some(a => { var _a; return a == ((_a = parseCommand.command) === null || _a === void 0 ? void 0 : _a.toLowerCase()); }))
+                : undefined);
             if (!command)
                 return;
-            if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = message.member) === null || _a === void 0 ? void 0 : _a.permissions, this.config.permissions.messageCommands, command)) {
+            if ((0, hasPermissions_1.hasPermissions)(command.name, (_b = message.member) === null || _b === void 0 ? void 0 : _b.permissions, this.config.permissions.messageCommands, command)) {
                 if (!command.allowExecuteInDM && message.channel.type === 'DM'
                     || !command.allowExecuteByBots
                         && (message.author.bot || message.author.system)

package/bin/reciple/classes/builders/InteractionCommandBuilder.d.ts

@@ -12,11 +12,17 @@ export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     requiredPermissions: (PermissionFlags | PermissionString)[];
     allowExecuteInDM: boolean;
     execute: (options: RecipleInteractionCommandExecute) => void;
+    /**
+     * Set required permissions before executing the command
+     */
     setRequiredPermissions(requiredPermissions: (keyof PermissionFlags)[]): InteractionCommandBuilder;
     /**
-     * TODO: Deprecated this
+     * Set if command can be executed in dms
      * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
      */
     setAllowExecuteInDM(allowExecuteInDM: boolean): InteractionCommandBuilder;
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
 }

package/bin/reciple/classes/builders/InteractionCommandBuilder.js

@@ -10,6 +10,9 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
         this.allowExecuteInDM = true;
         this.execute = () => { };
     }
+    /**
+     * Set required permissions before executing the command
+     */
     setRequiredPermissions(requiredPermissions) {
         if (!requiredPermissions || !Array.isArray(requiredPermissions))
             throw new Error('requiredPermissions must be an array.');
@@ -17,15 +20,20 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
         return this;
     }
     /**
-     * TODO: Deprecated this
+     * Set if command can be executed in dms
      * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
      */
     setAllowExecuteInDM(allowExecuteInDM) {
+        // TODO: Deprecated this
         if (typeof allowExecuteInDM !== 'boolean')
             throw new Error('allowExecuteInDM must be a boolean.');
         this.allowExecuteInDM = allowExecuteInDM;
+        process.emitWarning('InteractionCommandBuilder#setAllowExecuteInDM() method is deprecated in favor of setting SlashCommandBuilder#setDMPermission()', 'Deprecation Warning');
         return this;
     }
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
             throw new Error('execute must be a function.');

package/bin/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -22,19 +22,51 @@ export declare class MessageCommandBuilder {
     readonly builder = "MESSAGE_COMMAND";
     name: string;
     description: string;
+    aliases: string[];
     options: MessageCommandOptionBuilder[];
     validateOptions: boolean;
     requiredPermissions: (PermissionFlags | PermissionString)[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
     execute: (options: RecipleMessageCommandExecute) => void;
+    /**
+     * Sets the command name
+     */
     setName(name: string): MessageCommandBuilder;
+    /**
+     * Sets the command description
+     */
+    setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Add aliases to the command
+     */
+    addAliases(...aliases: string[]): MessageCommandBuilder;
+    /**
+     * Sets the default required permissions to execute this command
+     */
     setRequiredPermissions(permissions: (PermissionFlags | PermissionString)[]): MessageCommandBuilder;
+    /**
+     * Set if command can be executed in dms
+     */
     setAllowExecuteInDM(allowExecuteInDM: boolean): MessageCommandBuilder;
+    /**
+     * Allow command to be executed by bots
+     */
     setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
-    setDescription(description: string): MessageCommandBuilder;
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute: (options: RecipleMessageCommandExecute) => void): MessageCommandBuilder;
+    /**
+     * Add option to the command
+     */
     addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): MessageCommandBuilder;
+    /**
+     * Validate options before executing
+     */
     setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
+    /**
+     * validate given command options
+     */
     getCommandOptionValues(options: CommandMessage): MessageCommandValidatedOption[];
 }

package/bin/reciple/classes/builders/MessageCommandBuilder.js

@@ -7,6 +7,7 @@ class MessageCommandBuilder {
         this.builder = 'MESSAGE_COMMAND';
         this.name = '';
         this.description = '';
+        this.aliases = [];
         this.options = [];
         this.validateOptions = false;
         this.requiredPermissions = [];
@@ -14,42 +15,76 @@ class MessageCommandBuilder {
         this.allowExecuteByBots = false;
         this.execute = () => { };
     }
+    /**
+     * Sets the command name
+     */
     setName(name) {
         if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/');
         this.name = name;
         return this;
     }
+    /**
+     * Sets the command description
+     */
+    setDescription(description) {
+        if (!description || typeof description !== 'string')
+            throw new TypeError('description must be a string.');
+        this.description = description;
+        return this;
+    }
+    /**
+     * Add aliases to the command
+     */
+    addAliases(...aliases) {
+        if (!aliases.length)
+            throw new TypeError('Provide atleast one alias');
+        if (aliases.some(a => !a || typeof a !== 'string' || !a.match(/^[\w-]{1,32}$/)))
+            throw new TypeError('aliases must be strings and match the regex /^[\\w-]{1,32}$/');
+        if (this.name && aliases.some(a => a == this.name))
+            throw new TypeError('alias cannot have same name to its real command name');
+        this.aliases = [...new Set(aliases)];
+        return this;
+    }
+    /**
+     * Sets the default required permissions to execute this command
+     */
     setRequiredPermissions(permissions) {
         if (!permissions || !Array.isArray(permissions))
             throw new TypeError('permissions must be an array.');
         this.requiredPermissions = permissions;
         return this;
     }
+    /**
+     * Set if command can be executed in dms
+     */
     setAllowExecuteInDM(allowExecuteInDM) {
         if (typeof allowExecuteInDM !== 'boolean')
             throw new TypeError('allowExecuteInDM must be a boolean.');
         this.allowExecuteInDM = allowExecuteInDM;
         return this;
     }
+    /**
+     * Allow command to be executed by bots
+     */
     setAllowExecuteByBots(allowExecuteByBots) {
         if (typeof allowExecuteByBots !== 'boolean')
             throw new TypeError('allowExecuteByBots must be a boolean.');
         this.allowExecuteByBots = allowExecuteByBots;
         return this;
     }
-    setDescription(description) {
-        if (!description || typeof description !== 'string')
-            throw new TypeError('description must be a string.');
-        this.description = description;
-        return this;
-    }
+    /**
+     * Function when the command is executed
+     */
     setExecute(execute) {
         if (!execute || typeof execute !== 'function')
             throw new TypeError('execute must be a function.');
         this.execute = execute;
         return this;
     }
+    /**
+     * Add option to the command
+     */
     addOption(option) {
         if (!option)
             throw new TypeError('option must be a MessageOption.');
@@ -61,12 +96,18 @@ class MessageCommandBuilder {
         this.options = [...this.options, option];
         return this;
     }
+    /**
+     * Validate options before executing
+     */
     setValidateOptions(validateOptions) {
         if (typeof validateOptions !== 'boolean')
             throw new TypeError('validateOptions must be a boolean.');
         this.validateOptions = validateOptions;
         return this;
     }
+    /**
+     * validate given command options
+     */
     getCommandOptionValues(options) {
         const args = options.args || [];
         const required = this.options.filter(o => o.required);

package/bin/reciple/classes/builders/MessageCommandOptionBuilder.d.ts

@@ -3,8 +3,20 @@ export declare class MessageCommandOptionBuilder {
     description: string;
     required: boolean;
     validator: (value: string) => boolean;
+    /**
+     * Set command option name
+     */
     setName(name: string): MessageCommandOptionBuilder;
+    /**
+     * Set command option description
+     */
     setDescription(description: string): MessageCommandOptionBuilder;
+    /**
+     * Set if this option is required
+     */
     setRequired(required: boolean): MessageCommandOptionBuilder;
+    /**
+     * Set your custom function to validate given value for this option
+     */
     setValidator(validator: (value: string) => boolean): MessageCommandOptionBuilder;
 }

package/bin/reciple/classes/builders/MessageCommandOptionBuilder.js

@@ -8,24 +8,36 @@ class MessageCommandOptionBuilder {
         this.required = false;
         this.validator = () => true;
     }
+    /**
+     * Set command option name
+     */
     setName(name) {
         if (typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
             throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/.');
         this.name = name;
         return this;
     }
+    /**
+     * Set command option description
+     */
     setDescription(description) {
         if (!description || typeof description !== 'string')
             throw new TypeError('description must be a string.');
         this.description = description;
         return this;
     }
+    /**
+     * Set if this option is required
+     */
     setRequired(required) {
         if (typeof required !== 'boolean')
             throw new TypeError('required must be a boolean.');
         this.required = required;
         return this;
     }
+    /**
+     * Set your custom function to validate given value for this option
+     */
     setValidator(validator) {
         if (!validator || typeof validator !== 'function')
             throw new TypeError('validator must be a function.');

package/bin/reciple/classes/builders/MessageCommandOptions.d.ts

@@ -1,8 +1,14 @@
 import { MessageCommandValidatedOption } from './MessageCommandBuilder';
 export declare class MessageCommandOptions extends Array<MessageCommandValidatedOption> {
     constructor(options: MessageCommandValidatedOption[]);
+    /**
+     * Get the option info
+     */
     get(name: string, requied: true): MessageCommandValidatedOption;
     get(name: string, requied?: boolean): MessageCommandValidatedOption | null;
+    /**
+     * Get the option value
+     */
     getValue(name: string, requied: true): string;
     getValue(name: string, requied?: boolean): string | null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "A Discord.js bot",
   "author": "FalloutStudios",
   "license": "GPL-3.0",

package/resource/reciple.yml

@@ -13,6 +13,8 @@ commands:
     enabled: true
     # reply when an error occured
     replyOnError: false
+    # Allow executing commands via aliases
+    allowCommandAlias: false
     # command argument separator
     commandArgumentSeparator: ' '
   interactionCommand: