reciple 4.0.0 → 5.0.0-pre.1

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

@@ -1,7 +1,7 @@
 import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
-import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { CommandBuilder, CommandBuilderType } from '../types/builders';
 import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
+import { ApplicationCommandBuilder } from '../registerApplicationCommands';
+import { AnyCommandBuilder, CommandBuilderType } from '../types/builders';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { RecipleClientAddModuleOptions } from '../types/paramOptions';
 import { Logger as ILogger } from 'fallout-utility';
@@ -79,7 +79,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Add slash or message command to client
      * @param command Slash/Message command builder
      */
-    addCommand(command: CommandBuilder): RecipleClient<Ready>;
+    addCommand(command: AnyCommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */

package/bin/reciple/classes/RecipleClient.js

@@ -11,8 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
-const permissions_1 = require("../permissions");
+const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
 const registerApplicationCommands_1 = require("../registerApplicationCommands");
+const permissions_1 = require("../permissions");
 const builders_1 = require("../types/builders");
 const CommandCooldownManager_1 = require("./CommandCooldownManager");
 const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
@@ -134,10 +135,10 @@ class RecipleClient extends discord_js_1.Client {
      */
     addCommand(command) {
         var _a;
-        if (command.builder === builders_1.CommandBuilderType.MessageCommand) {
+        if (command.type === builders_1.CommandBuilderType.MessageCommand) {
             this.commands.messageCommands[command.name] = command;
         }
-        else if (command.builder === builders_1.CommandBuilderType.SlashCommand) {
+        else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
             this.commands.slashCommands[command.name] = command;
         }
         else if (this.isClientLogsEnabled()) {
@@ -171,7 +172,7 @@ class RecipleClient extends discord_js_1.Client {
             const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
             if (!command)
                 return;
-            const commandOptions = (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
+            const commandOptions = yield (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
             const executeData = {
                 message: message,
                 options: commandOptions,
@@ -191,20 +192,20 @@ class RecipleClient extends discord_js_1.Client {
                     return;
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)) }))) {
                             message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                     if (commandOptions.some(o => o.missing)) {
-                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)) }))) {
+                        if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingArguments, missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)) }))) {
                             message.reply(this.getMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
                         }
                         return;
                     }
                 }
                 if (message.guild && !(0, permissions_1.botHasExecutePermissions)(message.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingBotPermissions }))) {
                         message.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -220,7 +221,7 @@ class RecipleClient extends discord_js_1.Client {
                     this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
-                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.CommandHaltReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
                         yield message.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -228,16 +229,16 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleMessageCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingMemberPermissions }))) {
                 message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -249,7 +250,7 @@ class RecipleClient extends discord_js_1.Client {
     slashCommandExecute(interaction) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || interaction.type !== discord_js_1.InteractionType.ApplicationCommand || !interaction.isChatInputCommand() || !this.isReady())
+            if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
                 return;
             const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
             if (!command)
@@ -267,7 +268,7 @@ class RecipleClient extends discord_js_1.Client {
                 if (!command || (0, permissions_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (interaction.guild && !(0, permissions_1.botHasExecutePermissions)(interaction.guild, command.requiredBotPermissions)) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingBotPermissions }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingBotPermissions }))) {
                         yield interaction.reply(this.getMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -283,7 +284,7 @@ class RecipleClient extends discord_js_1.Client {
                     this.commandCooldowns.add(Object.assign(Object.assign({}, userCooldown), { expireTime: Date.now() + command.cooldown }));
                 }
                 else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
-                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.HaltedCommandReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
+                    if (!(yield this._haltCommand(command, Object.assign({ executeData, reason: commands_1.CommandHaltReason.Cooldown }, this.commandCooldowns.get(userCooldown))))) {
                         yield interaction.reply(this.getMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
                     }
                     return;
@@ -291,16 +292,16 @@ class RecipleClient extends discord_js_1.Client {
                 try {
                     yield Promise.resolve(command.execute(executeData))
                         .then(() => this.emit('recipleInteractionCommandCreate', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
+                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
                     return executeData;
                 }
                 catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.Error, error: err }))) {
+                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
                         this._commandExecuteError(err, executeData);
                     }
                 }
             }
-            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.HaltedCommandReason.MissingMemberPermissions }))) {
+            else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingMemberPermissions }))) {
                 yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
             }
         });
@@ -345,7 +346,7 @@ class RecipleClient extends discord_js_1.Client {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 return (_a = (command.halt
-                    ? yield (command.builder == builders_1.CommandBuilderType.SlashCommand
+                    ? yield (command.type == builders_1.CommandBuilderType.SlashCommand
                         ? Promise.resolve(command.halt(haltData))
                         : Promise.resolve(command.halt(haltData))).catch(err => { throw err; })
                     : false)) !== null && _a !== void 0 ? _a : false;
@@ -367,17 +368,17 @@ class RecipleClient extends discord_js_1.Client {
     _commandExecuteError(err, command) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isClientLogsEnabled()) {
-                this.logger.error(`An error occured executing ${command.builder.builder == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+                this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
                 this.logger.error(err);
             }
             if (!err || !command)
                 return;
-            if (command === null || command === void 0 ? void 0 : command.message) {
+            if (MessageCommandBuilder_1.MessageCommandBuilder.isMessageCommandExecuteData(command)) {
                 if (!this.config.commands.messageCommand.replyOnError)
                     return;
                 yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
             }
-            else if (command === null || command === void 0 ? void 0 : command.interaction) {
+            else if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandExecuteData(command)) {
                 if (!this.config.commands.slashCommand.replyOnError)
                     return;
                 yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(er => this._replyError(er));

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

@@ -72,7 +72,7 @@ export declare class RecipleConfig {
     /**
      * Parse the config file
      */
-    parseConfig(): RecipleConfig;
+    parseConfig(): this;
     /**
      * Returns the parsed config file
      */

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

@@ -1,9 +1,9 @@
+import { CommandBuilderType, AnyCommandExecuteData, AnyCommandExecuteFunction, AnyCommandHaltFunction } from '../../types/builders';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
-import { Awaitable, Message, PermissionResolvable } from 'discord.js';
 import { Command as CommandMessage } from 'fallout-utility';
-import { CommandBuilderType } from '../../types/builders';
-import { HaltedCommandData } from '../../types/commands';
+import { Message, PermissionResolvable } from 'discord.js';
+import { AnyCommandHaltData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
 /**
  * Execute data for message command
@@ -25,11 +25,23 @@ export interface MessageCommandValidatedOption {
     invalid: boolean;
     missing: boolean;
 }
+/**
+ * Message command halt data
+ */
+export declare type MessageCommandHaltData = AnyCommandHaltData<CommandBuilderType.MessageCommand>;
+/**
+ * Message command halt function
+ */
+export declare type MessageCommandHaltFunction = AnyCommandHaltFunction<CommandBuilderType.MessageCommand>;
+/**
+ * Message command execute function
+ */
+export declare type MessageCommandExecuteFunction = AnyCommandExecuteFunction<CommandBuilderType.MessageCommand>;
 /**
  * Reciple builder for message command
  */
 export declare class MessageCommandBuilder {
-    readonly builder = CommandBuilderType.MessageCommand;
+    readonly type = CommandBuilderType.MessageCommand;
     name: string;
     cooldown: number;
     description: string;
@@ -40,68 +52,80 @@ export declare class MessageCommandBuilder {
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
     allowExecuteByBots: boolean;
-    halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: MessageCommandExecuteData) => void;
+    halt?: MessageCommandHaltFunction;
+    execute: MessageCommandExecuteFunction;
     /**
      * Sets the command name
      * @param name Command name
      */
-    setName(name: string): MessageCommandBuilder;
+    setName(name: string): this;
     /**
      * Sets the command description
      * @param description Command description
      */
-    setDescription(description: string): MessageCommandBuilder;
+    setDescription(description: string): this;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
      * @param cooldown Command cooldown in milliseconds
      */
-    setCooldown(cooldown: number): MessageCommandBuilder;
+    setCooldown(cooldown: number): this;
     /**
      * Add aliases to the command
      * @param aliases Command aliases
      */
-    addAliases(...aliases: string[]): MessageCommandBuilder;
+    addAliases(...aliases: string[]): this;
     /**
      * Set required bot permissions to execute the command
      * @param permissions Bot's required permissions
      */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Set required permissions to execute the command
      * @param permissions User's return permissions
      */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): MessageCommandBuilder;
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Set if command can be executed in dms
      * @param allowExecuteInDM `true` if the command can execute in DMs
      */
-    setAllowExecuteInDM(allowExecuteInDM: boolean): MessageCommandBuilder;
+    setAllowExecuteInDM(allowExecuteInDM: boolean): this;
     /**
      * Allow command to be executed by bots
      * @param allowExecuteByBots `true` if the command can be executed by bots
      */
-    setAllowExecuteByBots(allowExecuteByBots: boolean): MessageCommandBuilder;
+    setAllowExecuteByBots(allowExecuteByBots: boolean): this;
     /**
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: (haltData: HaltedCommandData<MessageCommandBuilder>) => Awaitable<boolean | void>): MessageCommandBuilder;
+    setHalt(halt?: this["halt"]): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: (executeData: MessageCommandExecuteData) => void): MessageCommandBuilder;
+    setExecute(execute: this["execute"]): this;
     /**
      * Add option to the command
      * @param option Message option builder
      */
-    addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): MessageCommandBuilder;
+    addOption(option: MessageCommandOptionBuilder | ((constructor: MessageCommandOptionBuilder) => MessageCommandOptionBuilder)): this;
     /**
      * Validate options before executing
      * @param validateOptions `true` if the command options needs to be validated before executing
      */
-    setValidateOptions(validateOptions: boolean): MessageCommandBuilder;
+    setValidateOptions(validateOptions: boolean): this;
+    /**
+     * True if this is a message command builder
+     */
+    isMessageCommand(): this is MessageCommandBuilder;
+    /**
+     * Is a message command builder
+     */
+    static isMessageCommandBuilder(builder: any): builder is MessageCommandBuilder;
+    /**
+     * Is a message command execute data
+     */
+    static isMessageCommandExecuteData(executeData: AnyCommandExecuteData): executeData is MessageCommandExecuteData;
 }
-export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): MessageCommandOptionManager;
+export declare function validateMessageCommandOptions(builder: MessageCommandBuilder, options: CommandMessage): Promise<MessageCommandOptionManager>;

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

@@ -1,15 +1,24 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
+const builders_1 = require("../../types/builders");
 const MessageCommandOptionManager_1 = require("../MessageCommandOptionManager");
 const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
-const builders_1 = require("../../types/builders");
 /**
  * Reciple builder for message command
  */
 class MessageCommandBuilder {
     constructor() {
-        this.builder = builders_1.CommandBuilderType.MessageCommand;
+        this.type = builders_1.CommandBuilderType.MessageCommand;
         this.name = '';
         this.cooldown = 0;
         this.description = '';
@@ -144,39 +153,59 @@ class MessageCommandBuilder {
         this.validateOptions = validateOptions;
         return this;
     }
+    /**
+     * True if this is a message command builder
+     */
+    isMessageCommand() {
+        return this instanceof MessageCommandBuilder;
+    }
+    /**
+     * Is a message command builder
+     */
+    static isMessageCommandBuilder(builder) {
+        return builder instanceof MessageCommandBuilder;
+    }
+    /**
+     * Is a message command execute data
+     */
+    static isMessageCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isMessageCommandBuilder(executeData.builder);
+    }
 }
 exports.MessageCommandBuilder = MessageCommandBuilder;
 function validateMessageCommandOptions(builder, options) {
-    const args = options.args || [];
-    const required = builder.options.filter(o => o.required);
-    const optional = builder.options.filter(o => !o.required);
-    const allOptions = [...required, ...optional];
-    const result = [];
-    let i = 0;
-    for (const option of allOptions) {
-        const arg = args[i];
-        const value = {
-            name: option.name,
-            value: arg !== null && arg !== void 0 ? arg : undefined,
-            required: option.required,
-            invalid: false,
-            missing: false
-        };
-        if (arg == undefined && option.required) {
-            value.missing = true;
+    return __awaiter(this, void 0, void 0, function* () {
+        const args = options.args || [];
+        const required = builder.options.filter(o => o.required);
+        const optional = builder.options.filter(o => !o.required);
+        const allOptions = [...required, ...optional];
+        const result = [];
+        let i = 0;
+        for (const option of allOptions) {
+            const arg = args[i];
+            const value = {
+                name: option.name,
+                value: arg !== null && arg !== void 0 ? arg : undefined,
+                required: option.required,
+                invalid: false,
+                missing: false
+            };
+            if (arg == undefined && option.required) {
+                value.missing = true;
+                result.push(value);
+                continue;
+            }
+            if (arg == undefined && !option.required) {
+                result.push(value);
+                continue;
+            }
+            const validate = option.validator ? yield Promise.resolve(option.validator(arg)) : true;
+            if (!validate)
+                value.invalid = true;
             result.push(value);
-            continue;
+            i++;
         }
-        if (arg == undefined && !option.required) {
-            result.push(value);
-            continue;
-        }
-        const validate = option.validator ? option.validator(arg) : true;
-        if (!validate)
-            value.invalid = true;
-        result.push(value);
-        i++;
-    }
-    return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
+        return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
+    });
 }
 exports.validateMessageCommandOptions = validateMessageCommandOptions;

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

@@ -1,3 +1,4 @@
+import { Awaitable } from 'discord.js';
 /**
  * Option builder for MessageCommandBuilder
  */
@@ -5,25 +6,25 @@ export declare class MessageCommandOptionBuilder {
     name: string;
     description: string;
     required: boolean;
-    validator: (value: string) => boolean;
+    validator: (value: string) => Awaitable<boolean>;
     /**
      * Set command option name
      * @param name Option name
      */
-    setName(name: string): MessageCommandOptionBuilder;
+    setName(name: string): this;
     /**
      * Set command option description
      * @param description Option description
      */
-    setDescription(description: string): MessageCommandOptionBuilder;
+    setDescription(description: string): this;
     /**
      * Set if this option is required
      * @param required `true` if this option is required
      */
-    setRequired(required: boolean): MessageCommandOptionBuilder;
+    setRequired(required: boolean): this;
     /**
      * Set your custom function to validate given value for this option
      * @param validator Custom function to validate value given for this option
      */
-    setValidator(validator: (value: string) => boolean): MessageCommandOptionBuilder;
+    setValidator(validator: (value: string) => Awaitable<boolean>): this;
 }

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

@@ -1,7 +1,7 @@
-import { CommandBuilderType } from '../../types/builders';
-import { HaltedCommandData } from '../../types/commands';
+import { CommandBuilderType, AnyCommandExecuteData, AnyCommandExecuteFunction, AnyCommandHaltFunction } from '../../types/builders';
+import { AnyCommandHaltData } from '../../types/commands';
 import { RecipleClient } from '../RecipleClient';
-import { Awaitable, ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
+import { ChatInputCommandInteraction, PermissionResolvable, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder as DiscordJsSlashCommandSubcommandsOnlyBuilder } from 'discord.js';
 /**
  * Execute data for interaction command
  */
@@ -16,41 +16,65 @@ export interface SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
     addSubcommandGroup(input: SlashCommandSubcommandGroupBuilder | ((subcommandGroup: SlashCommandSubcommandGroupBuilder) => SlashCommandSubcommandGroupBuilder)): SlashCommandSubcommandsOnlyBuilder;
     addSubcommand(input: SlashCommandSubcommandBuilder | ((subcommandGroup: SlashCommandSubcommandBuilder) => SlashCommandSubcommandBuilder)): SlashCommandSubcommandsOnlyBuilder;
 }
+/**
+ * Slash command halt data
+ */
+export declare type SlashCommandHaltData = AnyCommandHaltData<CommandBuilderType.SlashCommand>;
+/**
+ * Slash command halt function
+ */
+export declare type SlashCommandHaltFunction = AnyCommandHaltFunction<CommandBuilderType.SlashCommand>;
+/**
+ * Slash command execute function
+ */
+export declare type SlashCommandExecuteFunction = AnyCommandExecuteFunction<CommandBuilderType.SlashCommand>;
 /**
  * Reciple builder for interaction/slash command
  */
 export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder {
-    readonly builder = CommandBuilderType.SlashCommand;
+    readonly type = CommandBuilderType.SlashCommand;
     cooldown: number;
     requiredBotPermissions: PermissionResolvable[];
     requiredMemberPermissions: PermissionResolvable[];
     allowExecuteInDM: boolean;
-    halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>;
-    execute: (executeData: SlashCommandExecuteData) => Awaitable<void>;
+    halt?: SlashCommandHaltFunction;
+    execute: SlashCommandExecuteFunction;
     /**
      * Sets the execute cooldown for this command.
      * - `0` means no cooldown
      * @param cooldown Command cooldown in milliseconds
      */
-    setCooldown(cooldown: number): SlashCommandBuilder;
+    setCooldown(cooldown: number): this;
     /**
      * Set required bot permissions to execute the command
      * @param permissions Bot's required permissions
      */
-    setRequiredBotPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    setRequiredBotPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Set required permissions to execute the command
      * @param permissions User's return permissions
      */
-    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): SlashCommandBuilder;
+    setRequiredMemberPermissions(...permissions: PermissionResolvable[]): this;
     /**
      * Function when the command is interupted
      * @param halt Function to execute when command is halted
      */
-    setHalt(halt?: (haltData: HaltedCommandData<SlashCommandBuilder>) => Awaitable<boolean | void>): SlashCommandBuilder;
+    setHalt(halt?: this["halt"]): this;
     /**
      * Function when the command is executed
      * @param execute Function to execute when the command is called
      */
-    setExecute(execute: (executeData: SlashCommandExecuteData) => void): SlashCommandBuilder;
+    setExecute(execute: this["execute"]): this;
+    /**
+     * True if this is a slash command builder
+     */
+    isSlashCommand(): this is SlashCommandBuilder;
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder: any): builder is SlashCommandBuilder;
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData: AnyCommandExecuteData): executeData is SlashCommandExecuteData;
 }

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

@@ -9,7 +9,7 @@ const discord_js_1 = require("discord.js");
 class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
     constructor() {
         super(...arguments);
-        this.builder = builders_1.CommandBuilderType.SlashCommand;
+        this.type = builders_1.CommandBuilderType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
@@ -59,5 +59,23 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
         this.execute = execute;
         return this;
     }
+    /**
+     * True if this is a slash command builder
+     */
+    isSlashCommand() {
+        return this instanceof SlashCommandBuilder;
+    }
+    /**
+     * Is a slash command builder
+     */
+    static isSlashCommandBuilder(builder) {
+        return builder instanceof SlashCommandBuilder;
+    }
+    /**
+     * Is a slash command execute data
+     */
+    static isSlashCommandExecuteData(executeData) {
+        return executeData.builder !== undefined && this.isSlashCommandBuilder(executeData.builder);
+    }
 }
 exports.SlashCommandBuilder = SlashCommandBuilder;

package/bin/reciple/modules.d.ts

@@ -1,7 +1,7 @@
-import { CommandBuilder } from './types/builders';
+import { AnyCommandBuilder } from './types/builders';
 import { RecipleClient } from './classes/RecipleClient';
 export declare type LoadedModules = {
-    commands: CommandBuilder[];
+    commands: AnyCommandBuilder[];
     modules: RecipleModule[];
 };
 /**
@@ -9,7 +9,7 @@ export declare type LoadedModules = {
  */
 export interface RecipleScript {
     versions: string | string[];
-    commands?: CommandBuilder[];
+    commands?: AnyCommandBuilder[];
     onLoad?(reciple: RecipleClient): void | Promise<void>;
     onStart(reciple: RecipleClient): boolean | Promise<boolean>;
 }

package/bin/reciple/modules.js

@@ -50,7 +50,7 @@ function loadModules(client, folder) {
                     throw new Error(script + ' onStart is not defined or returned false.');
                 if (module_.commands) {
                     for (const command of module_.commands) {
-                        if (command.builder === builders_1.CommandBuilderType.MessageCommand || command.builder === builders_1.CommandBuilderType.SlashCommand) {
+                        if (command.type === builders_1.CommandBuilderType.MessageCommand || command.type === builders_1.CommandBuilderType.SlashCommand) {
                             commands.push(command);
                         }
                     }
@@ -66,12 +66,12 @@ function loadModules(client, folder) {
             response.commands.push(...commands.filter((c) => {
                 if (!c.name) {
                     if (client.isClientLogsEnabled())
-                        client.logger.error(`A ${c.builder} command name is not defined in ${script}`);
+                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} command name is not defined in ${script}`);
                     return false;
                 }
-                if (c.builder === builders_1.CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
+                if (c.type === builders_1.CommandBuilderType.MessageCommand && c.options.length && c.options.some(o => !o.name)) {
                     if (client.isClientLogsEnabled())
-                        client.logger.error(`A ${c.builder} option name is not defined in ${script}`);
+                        client.logger.error(`A ${builders_1.CommandBuilderType[c.type]} option name is not defined in ${script}`);
                     return false;
                 }
                 return true;

package/bin/reciple/types/builders.d.ts

@@ -1,13 +1,22 @@
-import { MessageCommandBuilder, MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
+import { Awaitable } from 'discord.js';
 /**
  * Reciple command builders
  */
-export declare type CommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
+export declare type AnyCommandBuilder = MessageCommandBuilder | SlashCommandBuilder;
 /**
- * Reciple command builders execute data
+ * Reciple command execute data
  */
-export declare type CommandBuilderExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+export declare type AnyCommandExecuteData = SlashCommandExecuteData | MessageCommandExecuteData;
+/**
+ * Reciple command halt function
+ */
+export declare type AnyCommandHaltFunction<T extends CommandBuilderType> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData : MessageCommandHaltData) => Awaitable<boolean | null | undefined | void>;
+/**
+ * Reciple command execute function
+ */
+export declare type AnyCommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
 /**
  * Types of Reciple command builders
  */

package/bin/reciple/types/commands.d.ts

@@ -1,40 +1,43 @@
 import { MessageCommandExecuteData } from '../classes/builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
 import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
+import { SlashCommandExecuteData } from '../classes/builders/SlashCommandBuilder';
+import { CommandBuilderType, AnyCommandExecuteData } from '../types/builders';
 import { CooledDownUser } from '../classes/CommandCooldownManager';
-import { CommandBuilder } from '../types/builders';
 /**
- * Halted command's data
+ * Any Halted command's data
  */
-export declare type HaltedCommandData<Builder extends CommandBuilder = CommandBuilder> = CommandErrorData<Builder> | CommandCooldownData<Builder> | (Builder extends SlashCommandBuilder ? never : CommandInvalidArguments<Builder> | CommandMissingArguments<Builder>) | CommandMissingMemberPermissions<Builder> | CommandMissingBotPermissions<Builder>;
-export interface CommandHaltBaseData<Builder extends CommandBuilder> {
-    executeData: Builder extends SlashCommandBuilder ? SlashCommandExecuteData : MessageCommandExecuteData;
+export declare type AnyCommandHaltData<T extends CommandBuilderType = CommandBuilderType> = CommandErrorData<T> | CommandCooldownData<T> | (T extends CommandBuilderType.SlashCommand ? never : CommandInvalidArguments<T> | CommandMissingArguments<T>) | CommandMissingMemberPermissions<T> | CommandMissingBotPermissions<T>;
+/**
+ * Command halt reason base interface
+ */
+export interface CommandHaltReasonBase<T extends CommandBuilderType> {
+    executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : T extends CommandBuilderType.MessageCommand ? MessageCommandExecuteData : AnyCommandExecuteData;
 }
-export interface CommandErrorData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.Error;
+export interface CommandErrorData<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.Error;
     error: any;
 }
-export interface CommandCooldownData<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder>, CooledDownUser {
-    reason: HaltedCommandReason.Cooldown;
+export interface CommandCooldownData<T extends CommandBuilderType> extends CommandHaltReasonBase<T>, CooledDownUser {
+    reason: CommandHaltReason.Cooldown;
 }
-export interface CommandInvalidArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.InvalidArguments;
+export interface CommandInvalidArguments<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.InvalidArguments;
     invalidArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingArguments<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingArguments;
+export interface CommandMissingArguments<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingArguments;
     missingArguments: MessageCommandOptionManager;
 }
-export interface CommandMissingMemberPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingMemberPermissions;
+export interface CommandMissingMemberPermissions<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingMemberPermissions;
 }
-export interface CommandMissingBotPermissions<Builder extends CommandBuilder> extends CommandHaltBaseData<Builder> {
-    reason: HaltedCommandReason.MissingBotPermissions;
+export interface CommandMissingBotPermissions<T extends CommandBuilderType> extends CommandHaltReasonBase<T> {
+    reason: CommandHaltReason.MissingBotPermissions;
 }
 /**
  * Command halt reasons
  */
-export declare enum HaltedCommandReason {
+export declare enum CommandHaltReason {
     Error = 0,
     Cooldown = 1,
     InvalidArguments = 2,

package/bin/reciple/types/commands.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HaltedCommandReason = void 0;
+exports.CommandHaltReason = void 0;
 /**
  * Command halt reasons
  */
-var HaltedCommandReason;
-(function (HaltedCommandReason) {
-    HaltedCommandReason[HaltedCommandReason["Error"] = 0] = "Error";
-    HaltedCommandReason[HaltedCommandReason["Cooldown"] = 1] = "Cooldown";
-    HaltedCommandReason[HaltedCommandReason["InvalidArguments"] = 2] = "InvalidArguments";
-    HaltedCommandReason[HaltedCommandReason["MissingArguments"] = 3] = "MissingArguments";
-    HaltedCommandReason[HaltedCommandReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
-    HaltedCommandReason[HaltedCommandReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
-})(HaltedCommandReason = exports.HaltedCommandReason || (exports.HaltedCommandReason = {}));
+var CommandHaltReason;
+(function (CommandHaltReason) {
+    CommandHaltReason[CommandHaltReason["Error"] = 0] = "Error";
+    CommandHaltReason[CommandHaltReason["Cooldown"] = 1] = "Cooldown";
+    CommandHaltReason[CommandHaltReason["InvalidArguments"] = 2] = "InvalidArguments";
+    CommandHaltReason[CommandHaltReason["MissingArguments"] = 3] = "MissingArguments";
+    CommandHaltReason[CommandHaltReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
+    CommandHaltReason[CommandHaltReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
+})(CommandHaltReason = exports.CommandHaltReason || (exports.CommandHaltReason = {}));

package/bin/reciple/types/paramOptions.d.ts

@@ -3,7 +3,7 @@ import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
 import { RecipleModule, RecipleScript } from '../modules';
 import { RecipleClient } from '../classes/RecipleClient';
 import { Config } from '../classes/RecipleConfig';
-import { CommandBuilder } from './builders';
+import { AnyCommandBuilder } from './builders';
 export interface RecipleClientAddModuleOptions {
     /**
      * The Module script
@@ -33,7 +33,7 @@ export interface RegisterApplicationCommandsOptions {
     guilds?: string | string[];
 }
 export interface UserHasCommandPermissionsOptions {
-    builder: CommandBuilder;
+    builder: AnyCommandBuilder;
     memberPermissions?: PermissionsBitField;
     commandPermissions?: Config["commands"]["slashCommand"]["permissions"] | Config["commands"]["messageCommand"]["permissions"];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "4.0.0",
+  "version": "5.0.0-pre.1",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",
@@ -58,7 +58,7 @@
   "devDependencies": {
     "@types/node": "^18.6.1",
     "@types/semver": "^7.3.10",
-    "discord.js": "^14.0.3",
+    "discord.js": "^14.1.2",
     "rimraf": "^3.0.2",
     "typedoc": "^0.23.9",
     "typedoc-plugin-discord-types": "^1.0.2",
@@ -67,7 +67,7 @@
     "typescript": "^4.7.4"
   },
   "peerDependencies": {
-    "discord.js": "^14.0.3"
+    "discord.js": "^14.1.2"
   },
   "packageManager": "yarn@3.2.2"
 }