reciple 5.4.0-pre.2 → 5.4.1-pre.2

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

@@ -0,0 +1,363 @@
+import { MessageCommandBuilder, validateMessageCommandOptions } from './builders/MessageCommandBuilder';
+import { SlashCommandBuilder } from './builders/SlashCommandBuilder';
+import { CommandBuilderType } from '../types/builders';
+import { registerApplicationCommands } from '../registerApplicationCommands';
+import { CommandHaltReason } from '../types/commands';
+import { botHasExecutePermissions, userHasCommandPermissions } from '../permissions';
+import { CommandCooldownManager } from './CommandCooldownManager';
+import { MessageCommandOptionManager } from './MessageCommandOptionManager';
+import { getCommand } from 'fallout-utility';
+import { RecipleConfig } from './RecipleConfig';
+import { getModules } from '../modules';
+import { createLogger } from '../logger';
+import { version } from '../version';
+import { cwd } from '../flags';
+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

@@ -0,0 +1,92 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { isSupportedVersion, version } from '../version';
+import { input, replaceAll } from 'fallout-utility';
+import { cwd, token as __token } from '../flags';
+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

@@ -0,0 +1,218 @@
+import { CommandBuilderType } from '../../types/builders';
+import { normalizeArray } from 'discord.js';
+import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
+import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
+/**
+ * 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);
+}