reciple 5.4.1-pre.5 → 5.4.1

package/bin/mjs/reciple/classes/RecipleClient.js

@@ -1,363 +0,0 @@
-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();
-    commands = { slashCommands: {}, messageCommands: {} };
-    additionalApplicationCommands = [];
-    cooldowns = new CommandCooldownManager();
-    modules = [];
-    logger;
-    version = version;
-    /**
-     * @param options Client options
-     */
-    constructor(options) {
-        super(options);
-        this.logger = 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);
-    }
-    /**
-     * 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));
-        for (const folder of folders) {
-            if (this.isClientLogsEnabled())
-                this.logger.info(`Loading Modules from ${folder}`);
-            const modules = await getModules(this, folder).catch(() => null);
-            if (!modules) {
-                if (this.isClientLogsEnabled())
-                    this.logger.error(`Failed to load modules from ${folder}`);
-                continue;
-            }
-            this.modules.push(...modules.modules);
-        }
-        return this;
-    }
-    /**
-     * Execute `onLoad()` from client modules and register application commands if enabled
-     */
-    async loadModules() {
-        for (const m in this.modules) {
-            const module_ = this.modules[m];
-            if (typeof module_.script?.onLoad === 'function') {
-                await Promise.resolve(module_.script.onLoad(this)).catch(err => {
-                    if (this.isClientLogsEnabled()) {
-                        this.logger.error(`Error loading ${module_.info.filename ?? 'unknown module'}:`);
-                        this.logger.error(err);
-                    }
-                    this.modules = this.modules.filter((_r, i) => i.toString() !== m.toString());
-                });
-            }
-            if (typeof module_.script?.commands !== 'undefined') {
-                for (const command of module_.script.commands) {
-                    this.addCommand(command);
-                }
-            }
-        }
-        if (this.isClientLogsEnabled()) {
-            this.logger.info(`${this.modules.length} modules loaded.`);
-            this.logger.info(`${Object.keys(this.commands.messageCommands).length} message commands loaded.`);
-            this.logger.info(`${Object.keys(this.commands.slashCommands).length} slash commands loaded.`);
-        }
-        if (this.config.commands.slashCommand.registerCommands) {
-            await registerApplicationCommands({
-                client: this,
-                commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
-                guilds: this.config.commands.slashCommand.guilds
-            });
-        }
-        return this;
-    }
-    /**
-     * Add module
-     * @param options Module options
-     */
-    async addModule(options) {
-        const { script } = options;
-        const registerCommands = options.registerApplicationCommands;
-        const info = options.moduleInfo;
-        this.modules.push({
-            script,
-            info: {
-                filename: undefined,
-                versions: typeof script.versions == 'string' ? [script.versions] : script.versions,
-                path: undefined,
-                ...info
-            }
-        });
-        if (typeof script?.onLoad === 'function')
-            await Promise.resolve(script.onLoad(this));
-        if (this.isClientLogsEnabled())
-            this.logger.info(`${this.modules.length} modules loaded.`);
-        for (const command of script.commands ?? []) {
-            if (!command.name)
-                continue;
-            this.addCommand(command);
-        }
-        if (registerCommands)
-            await registerApplicationCommands({
-                client: this,
-                commands: [...Object.values(this.commands.slashCommands), ...this.additionalApplicationCommands],
-                guilds: this.config.commands.slashCommand.guilds
-            });
-    }
-    /**
-     * Add slash or message command to client
-     * @param command Slash/Message command builder
-     */
-    addCommand(command) {
-        if (command.type === CommandBuilderType.SlashCommand) {
-            this.commands.slashCommands[command.name] = SlashCommandBuilder.resolveSlashCommand(command);
-        }
-        else if (command.type === CommandBuilderType.MessageCommand) {
-            this.commands.messageCommands[command.name] = MessageCommandBuilder.resolveMessageCommand(command);
-        }
-        else if (this.isClientLogsEnabled()) {
-            this.logger.error(`Unknow command "${typeof command ?? 'unknown'}".`);
-        }
-        return this;
-    }
-    /**
-     * Listed to command executions
-     */
-    addCommandListeners() {
-        if (this.config.commands.messageCommand.enabled)
-            this.on('messageCreate', (message) => { this.messageCommandExecute(message); });
-        if (this.config.commands.slashCommand.enabled)
-            this.on('interactionCreate', (interaction) => { this.slashCommandExecute(interaction); });
-        return this;
-    }
-    /**
-     * Execute a slash command
-     * @param interaction Slash command interaction
-     */
-    async slashCommandExecute(interaction) {
-        if (!interaction || !interaction.isChatInputCommand() || !this.isReady())
-            return;
-        const command = this.findCommand(interaction.commandName, CommandBuilderType.SlashCommand);
-        if (!command)
-            return;
-        const executeData = {
-            interaction,
-            builder: command,
-            client: this
-        };
-        if (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 })) {
-                    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: 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) })) {
-                    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 })) {
-            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 = 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);
-        if (!command)
-            return;
-        const commandOptions = await validateMessageCommandOptions(command, parseCommand);
-        const executeData = {
-            message: message,
-            options: commandOptions,
-            command: parseCommand,
-            builder: command,
-            client: this
-        };
-        if (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))
-                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)) })) {
-                        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)) })) {
-                        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 })) {
-                    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: 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) })) {
-                    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 })) {
-            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;
-    }
-    findCommand(command, type) {
-        switch (type) {
-            case CommandBuilderType.SlashCommand:
-                return this.commands.slashCommands[command];
-            case 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()))
-                        : undefined);
-            default:
-                throw new TypeError('Unknown command type');
-        }
-    }
-    /**
-     * Returns true if client logs is enabled
-     */
-    isClientLogsEnabled() {
-        return !!this.config.fileLogging.clientLogs;
-    }
-    /**
-     * Emits the "recipleReplyError" event
-     * @param error Received Error
-     */
-    _replyError(error) {
-        this.emit('recipleReplyError', error);
-    }
-    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;
-            this.emit('recipleCommandHalt', haltData);
-            return haltResolved;
-        }
-        catch (err) {
-            if (this.isClientLogsEnabled()) {
-                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 === 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 })
-                ? this._commandExecuteError(err, executeData)
-                : void 0);
-            return executeData;
-        }
-        catch (err) {
-            if (!await this._haltCommand(command, { executeData: executeData, reason: CommandHaltReason.Error, error: err })) {
-                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.isClientLogsEnabled()) {
-            this.logger.error(`An error occured executing ${command.builder.type == CommandBuilderType.MessageCommand ? 'message' : 'slash'} command "${command.builder.name}"`);
-            this.logger.error(err);
-        }
-        if (!err || !command)
-            return;
-        if (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)) {
-            if (!this.config.commands.messageCommand.replyOnError)
-                return;
-            await command.message.reply(this.getConfigMessage('error', 'An error occurred.')).catch(er => this._replyError(er));
-        }
-    }
-}

package/bin/mjs/reciple/classes/RecipleConfig.js

@@ -1,92 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { isSupportedVersion, version } from '../version.js';
-import { input, replaceAll } from 'fallout-utility';
-import { cwd, token as __token } from '../flags.js';
-import path from 'path';
-import yaml from 'yaml';
-/**
- * Create/parse reciple config
- */
-export class RecipleConfig {
-    config = RecipleConfig.getDefaultConfig();
-    configPath = path.join(cwd, 'reciple.yml');
-    static defaultConfigPath = path.join(__dirname, '../../../resource/reciple.yml');
-    /**
-     * @param configPath Path to config
-     */
-    constructor(configPath) {
-        if (!configPath)
-            throw new Error('Config path is not defined');
-        this.configPath = configPath;
-    }
-    /**
-     * Parse the config file
-     */
-    parseConfig() {
-        if (!existsSync(this.configPath)) {
-            const defaultConfigPath = RecipleConfig.defaultConfigPath;
-            if (!existsSync(defaultConfigPath))
-                throw new Error('Default Config file not found. Please reinstall Reciple.');
-            const defaultConfig = replaceAll(readFileSync(defaultConfigPath, 'utf-8'), 'VERSION', version);
-            writeFileSync(this.configPath, defaultConfig, 'utf-8');
-            if (!existsSync(this.configPath))
-                throw new Error('Failed to create config file.');
-            this.config = yaml.parse(defaultConfig);
-            if (this.config && this.config.token === 'TOKEN') {
-                this.config.token = this._askToken() || this.config.token;
-                writeFileSync(this.configPath, replaceAll(defaultConfig, ' TOKEN', ` ${this.config.token}`), 'utf-8');
-            }
-            return this;
-        }
-        if (!existsSync(this.configPath))
-            throw new Error('Failed to read config file.');
-        const config = readFileSync(this.configPath, 'utf-8');
-        this.config = yaml.parse(config);
-        if (!this._isSupportedConfig())
-            throw new Error('Unsupported config version. Your config version: ' + (this.config?.version || 'No version specified.') + ', Reciple version: ' + version);
-        return this;
-    }
-    /**
-     * Returns the parsed config file
-     */
-    getConfig() {
-        if (!this.config)
-            throw new Error('Config is not parsed.');
-        this.config.token = this.parseToken() || 'TOKEN';
-        return this.config;
-    }
-    /**
-     * Parse token from config
-     * @param askIfNull Ask for token if the token is null/undefined
-     */
-    parseToken(askIfNull = true) {
-        let token = __token || this.config?.token || null;
-        if (!token)
-            return token || (askIfNull ? this._askToken() : null);
-        const envToken = token.toString().split(':');
-        if (envToken.length === 2 && envToken[0].toLocaleLowerCase() === 'env' && envToken[1]) {
-            token = process.env[envToken[1]] || null;
-        }
-        return token || (askIfNull ? this._askToken() : null);
-    }
-    /**
-     * Check if the config version is supported
-     */
-    _isSupportedConfig() {
-        return isSupportedVersion(this.config?.version || '0.0.0', version);
-    }
-    /**
-     * Ask for a token
-     */
-    _askToken() {
-        return __token || input({ text: 'Bot Token >>> ', echo: '*', repeatIfEmpty: true, sigint: true }) || null;
-    }
-    /**
-     * Get default config
-     */
-    static getDefaultConfig() {
-        if (!existsSync(this.defaultConfigPath))
-            throw new Error("Default config file does not exists.");
-        return yaml.parse(readFileSync(this.defaultConfigPath, 'utf-8'));
-    }
-}

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

@@ -1,218 +0,0 @@
-import { CommandBuilderType } from '../../types/builders.js';
-import { normalizeArray } from 'discord.js';
-import { MessageCommandOptionManager } from '../MessageCommandOptionManager.js';
-import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder.js';
-/**
- * Reciple builder for message command
- */
-export class MessageCommandBuilder {
-    type = CommandBuilderType.MessageCommand;
-    name = '';
-    description = '';
-    cooldown = 0;
-    aliases = [];
-    validateOptions = false;
-    options = [];
-    requiredBotPermissions = [];
-    requiredMemberPermissions = [];
-    allowExecuteInDM = true;
-    allowExecuteByBots = false;
-    halt;
-    execute = () => { };
-    constructor(data) {
-        if (data?.name !== undefined)
-            this.setName(data.name);
-        if (data?.description !== undefined)
-            this.setDescription(data.description);
-        if (data?.cooldown !== undefined)
-            this.setCooldown(Number(data?.cooldown));
-        if (data?.requiredBotPermissions !== undefined)
-            this.setRequiredBotPermissions(data.requiredBotPermissions);
-        if (data?.requiredMemberPermissions !== undefined)
-            this.setRequiredMemberPermissions(data.requiredMemberPermissions);
-        if (data?.halt !== undefined)
-            this.setHalt(this.halt);
-        if (data?.execute !== undefined)
-            this.setExecute(data.execute);
-        if (data?.aliases !== undefined)
-            this.addAliases(data.aliases);
-        if (data?.allowExecuteByBots)
-            this.setAllowExecuteByBots(true);
-        if (data?.allowExecuteInDM)
-            this.setAllowExecuteInDM(true);
-        if (data?.validateOptions)
-            this.setValidateOptions(true);
-        if (data?.options !== undefined)
-            this.options = data.options.map(o => o instanceof MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder(o));
-    }
-    /**
-     * Sets the command name
-     * @param name Command name
-     */
-    setName(name) {
-        if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
-            throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/');
-        this.name = name;
-        return this;
-    }
-    /**
-     * Sets the command description
-     * @param description Command description
-     */
-    setDescription(description) {
-        if (!description || typeof description !== 'string')
-            throw new TypeError('description must be a string.');
-        this.description = description;
-        return this;
-    }
-    /**
-     * Add aliases to the command
-     * @param aliases Command aliases
-     */
-    addAliases(...aliases) {
-        aliases = normalizeArray(aliases);
-        if (!aliases.length)
-            throw new TypeError('Provide atleast one alias');
-        if (aliases.some(a => !a || typeof a !== 'string' || a.match(/^\s+$/)))
-            throw new TypeError('aliases must be strings and should not contain whitespaces');
-        if (this.name && aliases.some(a => a == this.name))
-            throw new TypeError('alias cannot have same name to its real command name');
-        this.aliases = [...new Set(aliases.map(s => s.toLowerCase()))];
-        return this;
-    }
-    /**
-     * Set if command can be executed in dms
-     * @param allowExecuteInDM `true` if the command can execute in DMs
-     */
-    setAllowExecuteInDM(allowExecuteInDM) {
-        if (typeof allowExecuteInDM !== 'boolean')
-            throw new TypeError('allowExecuteInDM must be a boolean.');
-        this.allowExecuteInDM = allowExecuteInDM;
-        return this;
-    }
-    /**
-     * Allow command to be executed by bots
-     * @param allowExecuteByBots `true` if the command can be executed by bots
-     */
-    setAllowExecuteByBots(allowExecuteByBots) {
-        if (typeof allowExecuteByBots !== 'boolean')
-            throw new TypeError('allowExecuteByBots must be a boolean.');
-        this.allowExecuteByBots = allowExecuteByBots;
-        return this;
-    }
-    /**
-     * Add option to the command
-     * @param option Message option builder
-     */
-    addOption(option) {
-        if (!option)
-            throw new TypeError('option must be a MessageOption.');
-        option = typeof option === 'function' ? option(new 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)
-            throw new TypeError('All required options must be before optional options.');
-        this.options = [...this.options, option];
-        return this;
-    }
-    /**
-     * Validate options before executing
-     * @param validateOptions `true` if the command options needs to be validated before executing
-     */
-    setValidateOptions(validateOptions) {
-        if (typeof validateOptions !== 'boolean')
-            throw new TypeError('validateOptions must be a boolean.');
-        this.validateOptions = validateOptions;
-        return this;
-    }
-    setCooldown(cooldown) {
-        this.cooldown = cooldown;
-        return this;
-    }
-    setRequiredBotPermissions(...permissions) {
-        this.requiredBotPermissions = normalizeArray(permissions);
-        return this;
-    }
-    setRequiredMemberPermissions(...permissions) {
-        this.requiredMemberPermissions = normalizeArray(permissions);
-        return this;
-    }
-    setHalt(halt) {
-        this.halt = halt ?? undefined;
-        return this;
-    }
-    setExecute(execute) {
-        if (!execute || typeof execute !== 'function')
-            throw new TypeError('execute must be a function.');
-        this.execute = execute;
-        return this;
-    }
-    /**
-     * Returns JSON object of this builder
-     */
-    toJSON() {
-        return {
-            type: this.type,
-            name: this.name,
-            description: this.description,
-            aliases: this.aliases,
-            cooldown: this.cooldown,
-            requiredBotPermissions: this.requiredBotPermissions,
-            requiredMemberPermissions: this.requiredMemberPermissions,
-            halt: this.halt,
-            execute: this.execute,
-            allowExecuteByBots: this.allowExecuteByBots,
-            allowExecuteInDM: this.allowExecuteInDM,
-            validateOptions: this.validateOptions,
-            options: this.options.map(o => o.toJSON()),
-        };
-    }
-    static resolveMessageCommand(commandData) {
-        return this.isMessageCommandBuilder(commandData) ? commandData : new MessageCommandBuilder(commandData);
-    }
-    /**
-     * 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);
-    }
-}
-export 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);
-    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 ?? 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 ? await Promise.resolve(option.validator(arg)) : true;
-        if (!validate)
-            value.invalid = true;
-        result.push(value);
-        i++;
-    }
-    return new MessageCommandOptionManager(...result);
-}