reciple 5.4.1-pre.5 → 5.4.3

package/bin/{cjs/bin.js → bin.js}

@@ -1,18 +1,8 @@
 #!/usr/bin/env node
 "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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 const RecipleClient_1 = require("./reciple/classes/RecipleClient");
 const RecipleConfig_1 = require("./reciple/classes/RecipleConfig");
@@ -26,37 +16,36 @@ const discord_js_1 = require("discord.js");
 const path_1 = __importDefault(require("path"));
 const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
 const configPath = path_1.default.join(flags_1.cwd, './reciple.yml');
-if ((0, fs_1.readdirSync)(flags_1.cwd).filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !(0, fs_1.existsSync)((_a = flags_1.flags.config) !== null && _a !== void 0 ? _a : configPath)) {
-    const ask = (_c = (_b = (flags_1.flags.yes ? 'y' : null)) !== null && _b !== void 0 ? _b : (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ')) !== null && _c !== void 0 ? _c : '';
+if ((0, fs_1.readdirSync)(flags_1.cwd).filter(f => !f.startsWith('.') && allowedFiles.indexOf(f)).length > 0 && !(0, fs_1.existsSync)(flags_1.flags.config ?? configPath)) {
+    const ask = (flags_1.flags.yes ? 'y' : null) ?? (0, fallout_utility_1.input)('This directory does not contain reciple.yml. Would you like to init axis here? [y/n] ') ?? '';
     if (ask.toString().toLowerCase() !== 'y')
         process.exit(0);
 }
 let configParser;
 try {
-    configParser = new RecipleConfig_1.RecipleConfig((_d = flags_1.flags.config) !== null && _d !== void 0 ? _d : configPath).parseConfig();
+    configParser = new RecipleConfig_1.RecipleConfig(flags_1.flags.config ?? configPath).parseConfig();
 }
 catch (err) {
     console.error(`${chalk_1.default.bold.red('Config Error')}: ${chalk_1.default.white(err.message)}`);
     process.exit(1);
 }
 const config = configParser.getConfig();
-const client = new RecipleClient_1.RecipleClient(Object.assign({ config: config }, config.client));
+const client = new RecipleClient_1.RecipleClient({ config: config, ...config.client });
 if (config.fileLogging.clientLogs)
     client.logger.info('Starting Reciple client v' + version_1.rawVersion);
-(() => __awaiter(void 0, void 0, void 0, function* () {
-    yield client.startModules((0, discord_js_1.normalizeArray)(config.modulesFolder));
-    client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _e;
+(async () => {
+    await client.startModules((0, discord_js_1.normalizeArray)(config.modulesFolder));
+    client.on('ready', async () => {
         if (client.isClientLogsEnabled())
-            client.logger.warn(`Logged in as ${((_e = client.user) === null || _e === void 0 ? void 0 : _e.tag) || 'Unknown'}!`);
+            client.logger.warn(`Logged in as ${client.user?.tag || 'Unknown'}!`);
         client.on('cacheSweep', () => {
             client.cooldowns.clean();
         });
-        yield client.loadModules();
+        await client.loadModules();
         client.addCommandListeners();
-    }));
+    });
     client.login(config.token).catch(err => {
         if (client.isClientLogsEnabled())
             client.logger.error(err);
     });
-}))();
+})();

package/bin/{mjs/reciple → reciple}/classes/CommandCooldownManager.js

@@ -1,10 +1,13 @@
-import { normalizeArray } from 'discord.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandCooldownManager = void 0;
+const discord_js_1 = require("discord.js");
 /**
  * cooled-down users manager
  */
-export class CommandCooldownManager extends Array {
+class CommandCooldownManager extends Array {
     constructor(...data) {
-        super(...normalizeArray(data));
+        super(...(0, discord_js_1.normalizeArray)(data));
     }
     /**
      * Alias for `CommandCooldownManager#push()`
@@ -72,16 +75,17 @@ export class CommandCooldownManager extends Array {
      * @param data Cooled-down user data
      */
     static checkOptions(options, data) {
-        if (options?.user && options.user.id !== data.user.id)
+        if (options?.user !== undefined && options.user.id !== data.user.id)
             return false;
-        if (options?.guild && options.guild.id !== data.guild?.id)
+        if (options?.guild !== undefined && options.guild?.id !== data.guild?.id)
             return false;
-        if (options?.channel && options.channel.id !== data.channel?.id)
+        if (options?.channel !== undefined && options.channel.id !== data.channel?.id)
             return false;
-        if (options?.command && options.command !== data.command)
+        if (options?.command !== undefined && options.command !== data.command)
             return false;
-        if (options?.type && options.type !== data.type)
+        if (options?.type !== undefined && options.type !== data.type)
             return false;
         return true;
     }
 }
+exports.CommandCooldownManager = CommandCooldownManager;

package/bin/{cjs/reciple → reciple}/classes/MessageCommandOptionManager.js

@@ -11,16 +11,15 @@ class MessageCommandOptionManager extends Array {
     }
     get(name, required) {
         const option = this.find(o => o.name == name);
-        if (!(option === null || option === void 0 ? void 0 : option.value) == undefined && required)
+        if (!option?.value == undefined && required)
             throw new TypeError(`Can't find option named ${name}`);
-        return option !== null && option !== void 0 ? option : null;
+        return option ?? null;
     }
     getValue(name, requied) {
-        var _a;
         const option = this.get(name, requied);
-        if (!(option === null || option === void 0 ? void 0 : option.value) && requied)
+        if (!option?.value && requied)
             throw new TypeError(`Value of option named ${name} is undefined`);
-        return (_a = option === null || option === void 0 ? void 0 : option.value) !== null && _a !== void 0 ? _a : null;
+        return option?.value ?? null;
     }
 }
 exports.MessageCommandOptionManager = MessageCommandOptionManager;

package/bin/{types/reciple → reciple}/classes/RecipleClient.d.ts

@@ -39,13 +39,13 @@ export interface RecipleClientEvents extends ClientEvents {
  */
 export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
-    on<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
+    on<E extends string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
     once<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
-    once<E extends keyof string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
+    once<E extends keyof string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
     emit<E extends keyof RecipleClientEvents>(event: E, ...args: RecipleClientEvents[E]): boolean;
-    emit<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, ...args: any): boolean;
+    emit<E extends string | symbol>(event: E, ...args: any): boolean;
     off<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
-    off<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
+    off<E extends string | symbol>(event: E, listener: (...args: any) => Awaitable<void>): this;
     removeAllListeners<E extends keyof RecipleClientEvents>(event?: E): this;
     removeAllListeners(event?: string | symbol): this;
     isReady(): this is RecipleClient<true>;

package/bin/{mjs/reciple → reciple}/classes/RecipleClient.js

@@ -1,49 +1,55 @@
-import { MessageCommandBuilder, validateMessageCommandOptions } from './builders/MessageCommandBuilder.js';
-import { SlashCommandBuilder } from './builders/SlashCommandBuilder.js';
-import { CommandBuilderType } from '../types/builders.js';
-import { registerApplicationCommands } from '../registerApplicationCommands.js';
-import { CommandHaltReason } from '../types/commands.js';
-import { botHasExecutePermissions, userHasCommandPermissions } from '../permissions.js';
-import { CommandCooldownManager } from './CommandCooldownManager.js';
-import { MessageCommandOptionManager } from './MessageCommandOptionManager.js';
-import { getCommand } from 'fallout-utility';
-import { RecipleConfig } from './RecipleConfig.js';
-import { getModules } from '../modules.js';
-import { createLogger } from '../logger.js';
-import { version } from '../version.js';
-import { cwd } from '../flags.js';
-import path from 'path';
-import { ChannelType, Client, normalizeArray } from 'discord.js';
-export class RecipleClient extends Client {
-    config = RecipleConfig.getDefaultConfig();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipleClient = void 0;
+const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
+const builders_1 = require("../types/builders");
+const registerApplicationCommands_1 = require("../registerApplicationCommands");
+const commands_1 = require("../types/commands");
+const permissions_1 = require("../permissions");
+const CommandCooldownManager_1 = require("./CommandCooldownManager");
+const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
+const fallout_utility_1 = require("fallout-utility");
+const RecipleConfig_1 = require("./RecipleConfig");
+const modules_1 = require("../modules");
+const logger_1 = require("../logger");
+const version_1 = require("../version");
+const flags_1 = require("../flags");
+const path_1 = __importDefault(require("path"));
+const discord_js_1 = require("discord.js");
+class RecipleClient extends discord_js_1.Client {
+    config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
     commands = { slashCommands: {}, messageCommands: {} };
     additionalApplicationCommands = [];
-    cooldowns = new CommandCooldownManager();
+    cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
     modules = [];
     logger;
-    version = version;
+    version = version_1.version;
     /**
      * @param options Client options
      */
     constructor(options) {
         super(options);
-        this.logger = createLogger(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
+        this.logger = (0, logger_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
         if (!options.config)
             throw new Error('Config is not defined.');
         this.config = { ...this.config, ...(options.config ?? {}) };
         if (this.config.fileLogging.enabled)
-            this.logger.logFile(path.join(cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
+            this.logger.logFile(path_1.default.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
     }
     /**
      * Load modules from modules folder
      * @param folders List of folders that contains the modules you want to load
      */
     async startModules(...folders) {
-        folders = normalizeArray(folders).map(f => path.join(cwd, f));
+        folders = (0, discord_js_1.normalizeArray)(folders).map(f => path_1.default.join(flags_1.cwd, f));
         for (const folder of folders) {
             if (this.isClientLogsEnabled())
                 this.logger.info(`Loading Modules from ${folder}`);
-            const modules = await getModules(this, folder).catch(() => null);
+            const modules = await (0, modules_1.getModules)(this, folder).catch(() => null);
             if (!modules) {
                 if (this.isClientLogsEnabled())
                     this.logger.error(`Failed to load modules from ${folder}`);
@@ -80,7 +86,7 @@ export class RecipleClient extends Client {
             this.logger.info(`${Object.keys(this.commands.slashCommands).length} slash commands loaded.`);
         }
         if (this.config.commands.slashCommand.registerCommands) {
-            await registerApplicationCommands({
+            await (0, registerApplicationCommands_1.registerApplicationCommands)({
                 client: this,
                 commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
                 guilds: this.config.commands.slashCommand.guilds
@@ -115,7 +121,7 @@ export class RecipleClient extends Client {
             this.addCommand(command);
         }
         if (registerCommands)
-            await registerApplicationCommands({
+            await (0, registerApplicationCommands_1.registerApplicationCommands)({
                 client: this,
                 commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
                 guilds: this.config.commands.slashCommand.guilds
@@ -126,11 +132,11 @@ export class RecipleClient extends Client {
      * @param command Slash/Message command builder
      */
     addCommand(command) {
-        if (command.type === CommandBuilderType.SlashCommand) {
-            this.commands.slashCommands[command.name] = SlashCommandBuilder.resolveSlashCommand(command);
+        if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+            this.commands.slashCommands[command.name] = SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command);
         }
-        else if (command.type === CommandBuilderType.MessageCommand) {
-            this.commands.messageCommands[command.name] = MessageCommandBuilder.resolveMessageCommand(command);
+        else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+            this.commands.messageCommands[command.name] = MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command);
         }
         else if (this.isClientLogsEnabled()) {
             this.logger.error(`Unknow command "${typeof command ?? 'unknown'}".`);
@@ -154,7 +160,7 @@ export class RecipleClient extends Client {
     async slashCommandExecute(interaction) {
         if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
             return;
-        const command = this.findCommand(interaction.commandName, CommandBuilderType.SlashCommand);
+        const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
         if (!command)
             return;
         const executeData = {
@@ -162,15 +168,15 @@ export class RecipleClient extends Client {
             builder: command,
             client: this
         };
-        if (userHasCommandPermissions({
+        if ((0, permissions_1.userHasCommandPermissions)({
             builder: command,
             memberPermissions: interaction.memberPermissions ?? undefined,
             commandPermissions: this.config.commands.slashCommand.permissions
         })) {
             if (!command)
                 return;
-            if (interaction.guild && !botHasExecutePermissions(interaction.guild, command.requiredBotPermissions)) {
-                if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.MissingBotPermissions })) {
+            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;
@@ -180,20 +186,20 @@ export class RecipleClient extends Client {
                 command: command.name,
                 channel: interaction.channel ?? undefined,
                 guild: interaction.guild,
-                type: CommandBuilderType.SlashCommand
+                type: builders_1.CommandBuilderType.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: CommandHaltReason.Cooldown, ...this.cooldowns.get(userCooldown) })) {
+                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: CommandHaltReason.MissingMemberPermissions })) {
+        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));
         }
     }
@@ -205,13 +211,13 @@ export class RecipleClient extends Client {
     async messageCommandExecute(message, prefix) {
         if (!message.content || !this.isReady())
             return;
-        const parseCommand = getCommand(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
+        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.findCommand(parseCommand.command, CommandBuilderType.MessageCommand);
+        const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
         if (!command)
             return;
-        const commandOptions = await validateMessageCommandOptions(command, parseCommand);
+        const commandOptions = await (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
         const executeData = {
             message: message,
             options: commandOptions,
@@ -219,29 +225,29 @@ export class RecipleClient extends Client {
             builder: command,
             client: this
         };
-        if (userHasCommandPermissions({
+        if ((0, permissions_1.userHasCommandPermissions)({
             builder: command,
             memberPermissions: message.member?.permissions,
             commandPermissions: this.config.commands.messageCommand.permissions
         })) {
-            if (!command.allowExecuteInDM && message.channel.type === ChannelType.DM || !command.allowExecuteByBots && (message.author.bot || message.author.system))
+            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: CommandHaltReason.InvalidArguments, invalidArguments: new MessageCommandOptionManager(...executeData.options.filter(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: CommandHaltReason.MissingArguments, missingArguments: new MessageCommandOptionManager(...executeData.options.filter(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.guild && !botHasExecutePermissions(message.guild, command.requiredBotPermissions)) {
-                if (!await this._haltCommand(command, { executeData, reason: CommandHaltReason.MissingBotPermissions })) {
+            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;
@@ -251,20 +257,20 @@ export class RecipleClient extends Client {
                 command: command.name,
                 channel: message.channel,
                 guild: message.guild,
-                type: CommandBuilderType.MessageCommand
+                type: builders_1.CommandBuilderType.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: CommandHaltReason.Cooldown, ...this.cooldowns.get(userCooldown) })) {
+                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: CommandHaltReason.MissingMemberPermissions })) {
+        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));
         }
     }
@@ -278,9 +284,9 @@ export class RecipleClient extends Client {
     }
     findCommand(command, type) {
         switch (type) {
-            case CommandBuilderType.SlashCommand:
+            case builders_1.CommandBuilderType.SlashCommand:
                 return this.commands.slashCommands[command];
-            case CommandBuilderType.MessageCommand:
+            case builders_1.CommandBuilderType.MessageCommand:
                 return this.commands.messageCommands[command.toLowerCase()]
                     ?? (this.config.commands.messageCommand.allowCommandAlias
                         ? Object.values(this.commands.messageCommands).find(c => c.aliases.some(a => a == command?.toLowerCase()))
@@ -305,10 +311,10 @@ export class RecipleClient extends Client {
     async _haltCommand(command, haltData) {
         try {
             const haltResolved = (command.halt
-                ? await (command.type == CommandBuilderType.SlashCommand
-                    ? Promise.resolve(command.halt(haltData))
-                    : Promise.resolve(command.halt(haltData))).catch(err => { throw err; })
-                : false) ?? false;
+                ? await Promise.resolve(command.type == builders_1.CommandBuilderType.SlashCommand
+                    ? command.halt(haltData)
+                    : command.halt(haltData)).catch(err => { console.log(err); })
+                : false) || false;
             this.emit('recipleCommandHalt', haltData);
             return haltResolved;
         }
@@ -322,17 +328,17 @@ export class RecipleClient extends Client {
     }
     async _executeCommand(command, executeData) {
         try {
-            await Promise.resolve(command.type === CommandBuilderType.SlashCommand
+            await Promise.resolve(command.type === builders_1.CommandBuilderType.SlashCommand
                 ? command.execute(executeData)
                 : command.execute(executeData))
                 .then(() => this.emit('recipleCommandExecute', executeData))
-                .catch(async (err) => await this._haltCommand(command, { executeData: executeData, reason: CommandHaltReason.Error, error: err })
+                .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: CommandHaltReason.Error, error: err })) {
+            if (!await this._haltCommand(command, { executeData: executeData, reason: commands_1.CommandHaltReason.Error, error: err })) {
                 this._commandExecuteError(err, executeData);
             }
         }
@@ -344,20 +350,21 @@ export class RecipleClient extends Client {
      */
     async _commandExecuteError(err, command) {
         if (this.isClientLogsEnabled()) {
-            this.logger.error(`An error occured executing ${command.builder.type == 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 (SlashCommandBuilder.isSlashCommandExecuteData(command)) {
+        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.isMessageCommandExecuteData(command)) {
+        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;

package/bin/{cjs/reciple → reciple}/classes/RecipleConfig.js

@@ -14,12 +14,13 @@ const yaml_1 = __importDefault(require("yaml"));
  * Create/parse reciple config
  */
 class RecipleConfig {
+    config = RecipleConfig.getDefaultConfig();
+    configPath = path_1.default.join(flags_1.cwd, 'reciple.yml');
+    static defaultConfigPath = path_1.default.join(__dirname, '../../../resource/reciple.yml');
     /**
      * @param configPath Path to config
      */
     constructor(configPath) {
-        this.config = RecipleConfig.getDefaultConfig();
-        this.configPath = path_1.default.join(flags_1.cwd, 'reciple.yml');
         if (!configPath)
             throw new Error('Config path is not defined');
         this.configPath = configPath;
@@ -28,7 +29,6 @@ class RecipleConfig {
      * Parse the config file
      */
     parseConfig() {
-        var _a;
         if (!(0, fs_1.existsSync)(this.configPath)) {
             const defaultConfigPath = RecipleConfig.defaultConfigPath;
             if (!(0, fs_1.existsSync)(defaultConfigPath))
@@ -49,7 +49,7 @@ class RecipleConfig {
         const config = (0, fs_1.readFileSync)(this.configPath, 'utf-8');
         this.config = yaml_1.default.parse(config);
         if (!this._isSupportedConfig())
-            throw new Error('Unsupported config version. Your config version: ' + (((_a = this.config) === null || _a === void 0 ? void 0 : _a.version) || 'No version specified.') + ', Reciple version: ' + version_1.version);
+            throw new Error('Unsupported config version. Your config version: ' + (this.config?.version || 'No version specified.') + ', Reciple version: ' + version_1.version);
         return this;
     }
     /**
@@ -66,8 +66,7 @@ class RecipleConfig {
      * @param askIfNull Ask for token if the token is null/undefined
      */
     parseToken(askIfNull = true) {
-        var _a;
-        let token = flags_1.token || ((_a = this.config) === null || _a === void 0 ? void 0 : _a.token) || null;
+        let token = flags_1.token || this.config?.token || null;
         if (!token)
             return token || (askIfNull ? this._askToken() : null);
         const envToken = token.toString().split(':');
@@ -80,8 +79,7 @@ class RecipleConfig {
      * Check if the config version is supported
      */
     _isSupportedConfig() {
-        var _a;
-        return (0, version_1.isSupportedVersion)(((_a = this.config) === null || _a === void 0 ? void 0 : _a.version) || '0.0.0', version_1.version);
+        return (0, version_1.isSupportedVersion)(this.config?.version || '0.0.0', version_1.version);
     }
     /**
      * Ask for a token
@@ -99,4 +97,3 @@ class RecipleConfig {
     }
 }
 exports.RecipleConfig = RecipleConfig;
-RecipleConfig.defaultConfigPath = path_1.default.join(__dirname, '../../../resource/reciple.yml');

package/bin/{mjs/reciple → reciple}/classes/builders/MessageCommandBuilder.js

@@ -1,12 +1,15 @@
-import { CommandBuilderType } from '../../types/builders.js';
-import { normalizeArray } from 'discord.js';
-import { MessageCommandOptionManager } from '../MessageCommandOptionManager.js';
-import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
+const builders_1 = require("../../types/builders");
+const discord_js_1 = require("discord.js");
+const MessageCommandOptionManager_1 = require("../MessageCommandOptionManager");
+const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
 /**
  * Reciple builder for message command
  */
-export class MessageCommandBuilder {
-    type = CommandBuilderType.MessageCommand;
+class MessageCommandBuilder {
+    type = builders_1.CommandBuilderType.MessageCommand;
     name = '';
     description = '';
     cooldown = 0;
@@ -31,19 +34,19 @@ export class MessageCommandBuilder {
         if (data?.requiredMemberPermissions !== undefined)
             this.setRequiredMemberPermissions(data.requiredMemberPermissions);
         if (data?.halt !== undefined)
-            this.setHalt(this.halt);
+            this.setHalt(data.halt);
         if (data?.execute !== undefined)
             this.setExecute(data.execute);
         if (data?.aliases !== undefined)
             this.addAliases(data.aliases);
-        if (data?.allowExecuteByBots)
+        if (data?.allowExecuteByBots !== undefined)
             this.setAllowExecuteByBots(true);
-        if (data?.allowExecuteInDM)
+        if (data?.allowExecuteInDM !== undefined)
             this.setAllowExecuteInDM(true);
-        if (data?.validateOptions)
+        if (data?.validateOptions !== undefined)
             this.setValidateOptions(true);
         if (data?.options !== undefined)
-            this.options = data.options.map(o => o instanceof MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder(o));
+            this.options = data.options.map(o => o instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder(o));
     }
     /**
      * Sets the command name
@@ -70,7 +73,7 @@ export class MessageCommandBuilder {
      * @param aliases Command aliases
      */
     addAliases(...aliases) {
-        aliases = normalizeArray(aliases);
+        aliases = (0, discord_js_1.normalizeArray)(aliases);
         if (!aliases.length)
             throw new TypeError('Provide atleast one alias');
         if (aliases.some(a => !a || typeof a !== 'string' || a.match(/^\s+$/)))
@@ -107,7 +110,7 @@ export class MessageCommandBuilder {
     addOption(option) {
         if (!option)
             throw new TypeError('option must be a MessageOption.');
-        option = typeof option === 'function' ? option(new MessageCommandOptionBuilder()) : option;
+        option = typeof option === 'function' ? option(new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder()) : option;
         if (this.options.find(o => o.name === option.name))
             throw new TypeError('option with name "' + option.name + '" already exists.');
         if (this.options.length > 0 && !this.options[this.options.length - 1 < 0 ? 0 : this.options.length - 1].required && option.required)
@@ -130,11 +133,11 @@ export class MessageCommandBuilder {
         return this;
     }
     setRequiredBotPermissions(...permissions) {
-        this.requiredBotPermissions = normalizeArray(permissions);
+        this.requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
         return this;
     }
     setRequiredMemberPermissions(...permissions) {
-        this.requiredMemberPermissions = normalizeArray(permissions);
+        this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
         return this;
     }
     setHalt(halt) {
@@ -183,7 +186,8 @@ export class MessageCommandBuilder {
         return executeData.builder !== undefined && this.isMessageCommandBuilder(executeData.builder);
     }
 }
-export async function validateMessageCommandOptions(builder, options) {
+exports.MessageCommandBuilder = MessageCommandBuilder;
+async function validateMessageCommandOptions(builder, options) {
     const args = options.args || [];
     const required = builder.options.filter(o => o.required);
     const optional = builder.options.filter(o => !o.required);
@@ -214,5 +218,6 @@ export async function validateMessageCommandOptions(builder, options) {
         result.push(value);
         i++;
     }
-    return new MessageCommandOptionManager(...result);
+    return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
 }
+exports.validateMessageCommandOptions = validateMessageCommandOptions;