reciple 6.0.0-dev.26 → 6.0.0-dev.27

package/dist/lib/reciple/classes/RecipleClient.js

@@ -1,307 +1,307 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecipleClient = exports.RecipleEvents = void 0;
-const discord_js_1 = require("discord.js");
-const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
-const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
-const commands_1 = require("../types/commands");
-const CommandCooldownManager_1 = require("./managers/CommandCooldownManager");
-const builders_1 = require("../types/builders");
-const permissions_1 = require("../permissions");
-const MessageCommandOptionManager_1 = require("./managers/MessageCommandOptionManager");
-const ApplicationCommandManager_1 = require("./managers/ApplicationCommandManager");
-const CommandManager_1 = require("./managers/CommandManager");
-const ModuleManager_1 = require("./managers/ModuleManager");
-const RecipleConfig_1 = require("./RecipleConfig");
-const fallout_utility_1 = require("fallout-utility");
-const util_1 = require("../util");
-const version_js_1 = require("../version.js");
-const flags_1 = require("../flags");
-var RecipleEvents;
-(function (RecipleEvents) {
-    RecipleEvents["RecipleCommandExecute"] = "recipleCommandExecute";
-    RecipleEvents["RecipleCommandHalt"] = "recipleCommandHalt";
-    RecipleEvents["RecipleRegisterApplicationCommands"] = "recipleRegisterApplicationCommands";
-    RecipleEvents["RecipleReplyError"] = "recipleReplyError";
-    RecipleEvents["CommandExecute"] = "recipleCommandExecute";
-    RecipleEvents["CommandHalt"] = "recipleCommandHalt";
-    RecipleEvents["RegisterApplicationCommands"] = "recipleRegisterApplicationCommands";
-    RecipleEvents["ReplyError"] = "recipleReplyError";
-})(RecipleEvents = exports.RecipleEvents || (exports.RecipleEvents = {}));
-class RecipleClient extends discord_js_1.Client {
-    /**
-     * @param options Client options
-     */
-    constructor(options) {
-        super(options);
-        this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = new CommandManager_1.CommandManager({
-            client: this,
-        });
-        this.cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
-        this.modules = new ModuleManager_1.ModuleManager({
-            client: this,
-        });
-        this.version = version_js_1.version;
-        this.logger = (0, util_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
-        this.config = { ...this.config, ...(options.config ?? {}) };
-        if (this.config.fileLogging.enabled)
-            this.logger.logFile(util_1.path.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
-        this.cwd = options.cwd ?? process.cwd();
-        this.applicationCommands = new ApplicationCommandManager_1.ApplicationCommandManager(this);
-    }
-    get isClientLogsSilent() {
-        return !this.config.fileLogging.clientLogs;
-    }
-    /**
-     * Listed to command executions
-     */
-    addCommandListeners() {
-        this.on(discord_js_1.Events.MessageCreate, message => {
-            if (this.config.commands.messageCommand.enabled)
-                this.messageCommandExecute(message);
-        });
-        this.on(discord_js_1.Events.InteractionCreate, interaction => {
-            if (this.config.commands.slashCommand.enabled)
-                this.slashCommandExecute(interaction);
-        });
-        return this;
-    }
-    /**
-     * Execute a slash command
-     * @param interaction Slash command interaction
-     */
-    async slashCommandExecute(interaction) {
-        if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
-            return;
-        if (!this.config.commands.slashCommand.acceptRepliedInteractions && (interaction.replied || interaction.deferred))
-            return;
-        const command = this.commands.get(interaction.commandName, builders_1.CommandType.SlashCommand);
-        if (!command)
-            return;
-        const executeData = {
-            interaction,
-            builder: command,
-            client: this,
-        };
-        if ((0, permissions_1.userHasCommandPermissions)({
-            builder: command,
-            memberPermissions: interaction.memberPermissions ?? undefined,
-            commandPermissions: this.config.commands.slashCommand.permissions,
-        })) {
-            if (!command)
-                return;
-            if (interaction.inCachedGuild() && !(0, permissions_1.botHasExecutePermissions)(interaction.channel || interaction.guild, command.requiredBotPermissions)) {
-                if (!(await this._haltCommand(command, {
-                    executeData,
-                    reason: commands_1.CommandHaltReason.MissingBotPermissions,
-                }))) {
-                    await interaction.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
-                }
-                return;
-            }
-            const userCooldown = {
-                user: interaction.user,
-                command: command.name,
-                channel: interaction.channel ?? undefined,
-                guild: interaction.guild,
-                type: builders_1.CommandType.SlashCommand,
-            };
-            if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
-                this.cooldowns.add({
-                    ...userCooldown,
-                    expireTime: Date.now() + command.cooldown,
-                });
-            }
-            else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
-                if (!(await this._haltCommand(command, {
-                    executeData,
-                    reason: commands_1.CommandHaltReason.Cooldown,
-                    ...this.cooldowns.get(userCooldown),
-                }))) {
-                    await interaction.reply(this.getConfigMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
-                }
-                return;
-            }
-            return this._executeCommand(command, executeData);
-        }
-        else if (!(await this._haltCommand(command, {
-            executeData,
-            reason: commands_1.CommandHaltReason.MissingMemberPermissions,
-        }))) {
-            await interaction.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
-        }
-    }
-    /**
-     * Execute a Message command
-     * @param message Message command executor
-     * @param prefix Message command prefix
-     */
-    async messageCommandExecute(message, prefix) {
-        if (!message.content || !this.isReady())
-            return;
-        const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
-        if (!parseCommand || !parseCommand?.command)
-            return;
-        const command = this.commands.get(parseCommand.command, builders_1.CommandType.MessageCommand);
-        if (!command)
-            return;
-        const commandOptions = await MessageCommandBuilder_1.MessageCommandBuilder.validateOptions(command, parseCommand);
-        const executeData = {
-            message: message,
-            options: commandOptions,
-            command: parseCommand,
-            builder: command,
-            client: this,
-        };
-        if ((0, permissions_1.userHasCommandPermissions)({
-            builder: command,
-            memberPermissions: message.member?.permissions,
-            commandPermissions: this.config.commands.messageCommand.permissions,
-        })) {
-            if ((!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM) || (!command.allowExecuteByBots && (message.author.bot || message.author.system)))
-                return;
-            if (command.validateOptions) {
-                if (commandOptions.some(o => o.invalid)) {
-                    if (!(await this._haltCommand(command, {
-                        executeData,
-                        reason: commands_1.CommandHaltReason.InvalidArguments,
-                        invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)),
-                    }))) {
-                        message.reply(this.getConfigMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this._replyError(er));
-                    }
-                    return;
-                }
-                if (commandOptions.some(o => o.missing)) {
-                    if (!(await this._haltCommand(command, {
-                        executeData,
-                        reason: commands_1.CommandHaltReason.MissingArguments,
-                        missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)),
-                    }))) {
-                        message.reply(this.getConfigMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
-                    }
-                    return;
-                }
-            }
-            if (message.inGuild() && !(0, permissions_1.botHasExecutePermissions)(message.channel || message.guild, command.requiredBotPermissions)) {
-                if (!(await this._haltCommand(command, {
-                    executeData,
-                    reason: commands_1.CommandHaltReason.MissingBotPermissions,
-                }))) {
-                    message.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
-                }
-                return;
-            }
-            const userCooldown = {
-                user: message.author,
-                command: command.name,
-                channel: message.channel,
-                guild: message.guild,
-                type: builders_1.CommandType.MessageCommand,
-            };
-            if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
-                this.cooldowns.add({
-                    ...userCooldown,
-                    expireTime: Date.now() + command.cooldown,
-                });
-            }
-            else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
-                if (!(await this._haltCommand(command, {
-                    executeData,
-                    reason: commands_1.CommandHaltReason.Cooldown,
-                    ...this.cooldowns.get(userCooldown),
-                }))) {
-                    await message.reply(this.getConfigMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
-                }
-                return;
-            }
-            return this._executeCommand(command, executeData);
-        }
-        else if (!(await this._haltCommand(command, {
-            executeData,
-            reason: commands_1.CommandHaltReason.MissingMemberPermissions,
-        }))) {
-            message.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
-        }
-    }
-    /**
-     * Get a message from config
-     * @param messageKey Config messages key
-     * @param defaultMessage Default message when the key does not exists
-     */
-    getConfigMessage(messageKey, defaultMessage) {
-        return this.config.messages[messageKey] ?? defaultMessage ?? messageKey;
-    }
-    /**
-     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
-     * @param error Received Error
-     */
-    _replyError(error) {
-        this.emit(RecipleEvents.ReplyError, error);
-    }
-    async _haltCommand(command, haltData) {
-        try {
-            const haltResolved = (command.halt
-                ? await Promise.resolve(command.type == builders_1.CommandType.SlashCommand ? command.halt(haltData) : command.halt(haltData)).catch(err => {
-                    console.log(err);
-                })
-                : false) || false;
-            this.emit(RecipleEvents.CommandHalt, haltData);
-            return haltResolved;
-        }
-        catch (err) {
-            if (!this.isClientLogsSilent) {
-                this.logger.error(`An error occured executing command halt for "${command.name}"`);
-                this.logger.error(err);
-            }
-            return false;
-        }
-    }
-    async _executeCommand(command, executeData) {
-        try {
-            await Promise.resolve(command.type === builders_1.CommandType.SlashCommand ? command.execute(executeData) : command.execute(executeData))
-                .then(() => this.emit(RecipleEvents.CommandExecute, executeData))
-                .catch(async (err) => !(await this._haltCommand(command, {
-                executeData: executeData,
-                reason: commands_1.CommandHaltReason.Error,
-                error: err,
-            }))
-                ? this._commandExecuteError(err, executeData)
-                : void 0);
-            return executeData;
-        }
-        catch (err) {
-            if (await this._haltCommand(command, {
-                executeData: executeData,
-                reason: commands_1.CommandHaltReason.Error,
-                error: err,
-            }))
-                return;
-            await this._commandExecuteError(err, executeData);
-        }
-    }
-    /**
-     * Error message when a command fails to execute
-     * @param err Received error
-     * @param command Slash/Message command execute data
-     */
-    async _commandExecuteError(err, command) {
-        if (!this.isClientLogsSilent) {
-            this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
-            this.logger.error(err);
-        }
-        if (!err || !command)
-            return;
-        if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandExecuteData(command)) {
-            if (!this.config.commands.slashCommand.replyOnError)
-                return;
-            await command.interaction.followUp(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
-        }
-        else if (MessageCommandBuilder_1.MessageCommandBuilder.isMessageCommandExecuteData(command)) {
-            if (!this.config.commands.messageCommand.replyOnError)
-                return;
-            await command.message.reply(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
-        }
-    }
-}
-exports.RecipleClient = RecipleClient;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipleClient = exports.RecipleEvents = void 0;
+const discord_js_1 = require("discord.js");
+const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
+const commands_1 = require("../types/commands");
+const CommandCooldownManager_1 = require("./managers/CommandCooldownManager");
+const builders_1 = require("../types/builders");
+const permissions_1 = require("../permissions");
+const MessageCommandOptionManager_1 = require("./managers/MessageCommandOptionManager");
+const ApplicationCommandManager_1 = require("./managers/ApplicationCommandManager");
+const CommandManager_1 = require("./managers/CommandManager");
+const ModuleManager_1 = require("./managers/ModuleManager");
+const RecipleConfig_1 = require("./RecipleConfig");
+const fallout_utility_1 = require("fallout-utility");
+const util_1 = require("../util");
+const version_js_1 = require("../version.js");
+const flags_1 = require("../flags");
+var RecipleEvents;
+(function (RecipleEvents) {
+    RecipleEvents["RecipleCommandExecute"] = "recipleCommandExecute";
+    RecipleEvents["RecipleCommandHalt"] = "recipleCommandHalt";
+    RecipleEvents["RecipleRegisterApplicationCommands"] = "recipleRegisterApplicationCommands";
+    RecipleEvents["RecipleReplyError"] = "recipleReplyError";
+    RecipleEvents["CommandExecute"] = "recipleCommandExecute";
+    RecipleEvents["CommandHalt"] = "recipleCommandHalt";
+    RecipleEvents["RegisterApplicationCommands"] = "recipleRegisterApplicationCommands";
+    RecipleEvents["ReplyError"] = "recipleReplyError";
+})(RecipleEvents = exports.RecipleEvents || (exports.RecipleEvents = {}));
+class RecipleClient extends discord_js_1.Client {
+    /**
+     * @param options Client options
+     */
+    constructor(options) {
+        super(options);
+        this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
+        this.commands = new CommandManager_1.CommandManager({
+            client: this,
+        });
+        this.cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
+        this.modules = new ModuleManager_1.ModuleManager({
+            client: this,
+        });
+        this.version = version_js_1.version;
+        this.logger = (0, util_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
+        this.config = { ...this.config, ...(options.config ?? {}) };
+        if (this.config.fileLogging.enabled)
+            this.logger.logFile(util_1.path.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
+        this.cwd = options.cwd ?? process.cwd();
+        this.applicationCommands = new ApplicationCommandManager_1.ApplicationCommandManager(this);
+    }
+    get isClientLogsSilent() {
+        return !this.config.fileLogging.clientLogs;
+    }
+    /**
+     * Listed to command executions
+     */
+    addCommandListeners() {
+        this.on(discord_js_1.Events.MessageCreate, message => {
+            if (this.config.commands.messageCommand.enabled)
+                this.messageCommandExecute(message);
+        });
+        this.on(discord_js_1.Events.InteractionCreate, interaction => {
+            if (this.config.commands.slashCommand.enabled)
+                this.slashCommandExecute(interaction);
+        });
+        return this;
+    }
+    /**
+     * Execute a slash command
+     * @param interaction Slash command interaction
+     */
+    async slashCommandExecute(interaction) {
+        if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
+            return;
+        if (!this.config.commands.slashCommand.acceptRepliedInteractions && (interaction.replied || interaction.deferred))
+            return;
+        const command = this.commands.get(interaction.commandName, builders_1.CommandType.SlashCommand);
+        if (!command)
+            return;
+        const executeData = {
+            interaction,
+            builder: command,
+            client: this,
+        };
+        if ((0, permissions_1.userHasCommandPermissions)({
+            builder: command,
+            memberPermissions: interaction.memberPermissions ?? undefined,
+            commandPermissions: this.config.commands.slashCommand.permissions,
+        })) {
+            if (!command)
+                return;
+            if (interaction.inCachedGuild() && !(0, permissions_1.botHasExecutePermissions)(interaction.channel || interaction.guild, command.requiredBotPermissions)) {
+                if (!(await this._haltCommand(command, {
+                    executeData,
+                    reason: commands_1.CommandHaltReason.MissingBotPermissions,
+                }))) {
+                    await interaction.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            const userCooldown = {
+                user: interaction.user,
+                command: command.name,
+                channel: interaction.channel ?? undefined,
+                guild: interaction.guild,
+                type: builders_1.CommandType.SlashCommand,
+            };
+            if (this.config.commands.slashCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                this.cooldowns.add({
+                    ...userCooldown,
+                    expireTime: Date.now() + command.cooldown,
+                });
+            }
+            else if (this.config.commands.slashCommand.enableCooldown && command.cooldown) {
+                if (!(await this._haltCommand(command, {
+                    executeData,
+                    reason: commands_1.CommandHaltReason.Cooldown,
+                    ...this.cooldowns.get(userCooldown),
+                }))) {
+                    await interaction.reply(this.getConfigMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            return this._executeCommand(command, executeData);
+        }
+        else if (!(await this._haltCommand(command, {
+            executeData,
+            reason: commands_1.CommandHaltReason.MissingMemberPermissions,
+        }))) {
+            await interaction.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
+        }
+    }
+    /**
+     * Execute a Message command
+     * @param message Message command executor
+     * @param prefix Message command prefix
+     */
+    async messageCommandExecute(message, prefix) {
+        if (!message.content || !this.isReady())
+            return;
+        const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
+        if (!parseCommand || !parseCommand?.command)
+            return;
+        const command = this.commands.get(parseCommand.command, builders_1.CommandType.MessageCommand);
+        if (!command)
+            return;
+        const commandOptions = await MessageCommandBuilder_1.MessageCommandBuilder.validateOptions(command, parseCommand);
+        const executeData = {
+            message: message,
+            options: commandOptions,
+            command: parseCommand,
+            builder: command,
+            client: this,
+        };
+        if ((0, permissions_1.userHasCommandPermissions)({
+            builder: command,
+            memberPermissions: message.member?.permissions,
+            commandPermissions: this.config.commands.messageCommand.permissions,
+        })) {
+            if ((!command.allowExecuteInDM && message.channel.type === discord_js_1.ChannelType.DM) || (!command.allowExecuteByBots && (message.author.bot || message.author.system)))
+                return;
+            if (command.validateOptions) {
+                if (commandOptions.some(o => o.invalid)) {
+                    if (!(await this._haltCommand(command, {
+                        executeData,
+                        reason: commands_1.CommandHaltReason.InvalidArguments,
+                        invalidArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.invalid)),
+                    }))) {
+                        message.reply(this.getConfigMessage('invalidArguments', 'Invalid argument(s) given.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+                if (commandOptions.some(o => o.missing)) {
+                    if (!(await this._haltCommand(command, {
+                        executeData,
+                        reason: commands_1.CommandHaltReason.MissingArguments,
+                        missingArguments: new MessageCommandOptionManager_1.MessageCommandOptionManager(...executeData.options.filter(o => o.missing)),
+                    }))) {
+                        message.reply(this.getConfigMessage('missingArguments', 'Not enough arguments.')).catch(er => this._replyError(er));
+                    }
+                    return;
+                }
+            }
+            if (message.inGuild() && !(0, permissions_1.botHasExecutePermissions)(message.channel || message.guild, command.requiredBotPermissions)) {
+                if (!(await this._haltCommand(command, {
+                    executeData,
+                    reason: commands_1.CommandHaltReason.MissingBotPermissions,
+                }))) {
+                    message.reply(this.getConfigMessage('insufficientBotPerms', 'Insufficient bot permissions.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            const userCooldown = {
+                user: message.author,
+                command: command.name,
+                channel: message.channel,
+                guild: message.guild,
+                type: builders_1.CommandType.MessageCommand,
+            };
+            if (this.config.commands.messageCommand.enableCooldown && command.cooldown && !this.cooldowns.isCooledDown(userCooldown)) {
+                this.cooldowns.add({
+                    ...userCooldown,
+                    expireTime: Date.now() + command.cooldown,
+                });
+            }
+            else if (this.config.commands.messageCommand.enableCooldown && command.cooldown) {
+                if (!(await this._haltCommand(command, {
+                    executeData,
+                    reason: commands_1.CommandHaltReason.Cooldown,
+                    ...this.cooldowns.get(userCooldown),
+                }))) {
+                    await message.reply(this.getConfigMessage('cooldown', 'You cannot execute this command right now due to the cooldown.')).catch(er => this._replyError(er));
+                }
+                return;
+            }
+            return this._executeCommand(command, executeData);
+        }
+        else if (!(await this._haltCommand(command, {
+            executeData,
+            reason: commands_1.CommandHaltReason.MissingMemberPermissions,
+        }))) {
+            message.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
+        }
+    }
+    /**
+     * Get a message from config
+     * @param messageKey Config messages key
+     * @param defaultMessage Default message when the key does not exists
+     */
+    getConfigMessage(messageKey, defaultMessage) {
+        return this.config.messages[messageKey] ?? defaultMessage ?? messageKey;
+    }
+    /**
+     * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
+     * @param error Received Error
+     */
+    _replyError(error) {
+        this.emit(RecipleEvents.ReplyError, error);
+    }
+    async _haltCommand(command, haltData) {
+        try {
+            const haltResolved = (command.halt
+                ? await Promise.resolve(command.type == builders_1.CommandType.SlashCommand ? command.halt(haltData) : command.halt(haltData)).catch(err => {
+                    console.log(err);
+                })
+                : false) || false;
+            this.emit(RecipleEvents.CommandHalt, haltData);
+            return haltResolved;
+        }
+        catch (err) {
+            if (!this.isClientLogsSilent) {
+                this.logger.error(`An error occured executing command halt for "${command.name}"`);
+                this.logger.error(err);
+            }
+            return false;
+        }
+    }
+    async _executeCommand(command, executeData) {
+        try {
+            await Promise.resolve(command.type === builders_1.CommandType.SlashCommand ? command.execute(executeData) : command.execute(executeData))
+                .then(() => this.emit(RecipleEvents.CommandExecute, executeData))
+                .catch(async (err) => !(await this._haltCommand(command, {
+                executeData: executeData,
+                reason: commands_1.CommandHaltReason.Error,
+                error: err,
+            }))
+                ? this._commandExecuteError(err, executeData)
+                : void 0);
+            return executeData;
+        }
+        catch (err) {
+            if (await this._haltCommand(command, {
+                executeData: executeData,
+                reason: commands_1.CommandHaltReason.Error,
+                error: err,
+            }))
+                return;
+            await this._commandExecuteError(err, executeData);
+        }
+    }
+    /**
+     * Error message when a command fails to execute
+     * @param err Received error
+     * @param command Slash/Message command execute data
+     */
+    async _commandExecuteError(err, command) {
+        if (!this.isClientLogsSilent) {
+            this.logger.error(`An error occured executing ${command.builder.type == builders_1.CommandType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
+            this.logger.error(err);
+        }
+        if (!err || !command)
+            return;
+        if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandExecuteData(command)) {
+            if (!this.config.commands.slashCommand.replyOnError)
+                return;
+            await command.interaction.followUp(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
+        }
+        else if (MessageCommandBuilder_1.MessageCommandBuilder.isMessageCommandExecuteData(command)) {
+            if (!this.config.commands.messageCommand.replyOnError)
+                return;
+            await command.message.reply(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
+        }
+    }
+}
+exports.RecipleClient = RecipleClient;