reciple 5.3.0 → 5.4.0

package/bin/index.d.ts

@@ -13,4 +13,5 @@ export * from './reciple/logger';
 export * from './reciple/modules';
 export * from './reciple/permissions';
 export * from './reciple/registerApplicationCommands';
+export * from './reciple/util';
 export * from './reciple/version';

package/bin/index.js

@@ -29,4 +29,5 @@ __exportStar(require("./reciple/logger"), exports);
 __exportStar(require("./reciple/modules"), exports);
 __exportStar(require("./reciple/permissions"), exports);
 __exportStar(require("./reciple/registerApplicationCommands"), exports);
+__exportStar(require("./reciple/util"), exports);
 __exportStar(require("./reciple/version"), exports);

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

@@ -1,7 +1,7 @@
-import { MessageCommandBuilder, MessageCommandExecuteData } from './builders/MessageCommandBuilder';
-import { SlashCommandBuilder, SlashCommandExecuteData } from './builders/SlashCommandBuilder';
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
+import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } from './builders/SlashCommandBuilder';
+import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType } from '../types/builders';
 import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { AnyCommandBuilder, AnySlashCommandBuilder, CommandBuilderType } from '../types/builders';
 import { AnyCommandExecuteData, AnyCommandHaltData } from '../types/commands';
 import { CommandCooldownManager } from './CommandCooldownManager';
 import { RecipleClientAddModuleOptions } from '../types/paramOptions';
@@ -80,7 +80,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Add slash or message command to client
      * @param command Slash/Message command builder
      */
-    addCommand(command: AnyCommandBuilder): RecipleClient<Ready>;
+    addCommand(command: AnyCommandData | AnyCommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
@@ -117,17 +117,25 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Emits the "recipleReplyError" event
      * @param error Received Error
      */
-    private _replyError;
+    protected _replyError(error: unknown): void;
     /**
      * Executes command halt function
      * @param command Halted command's builder
      * @param haltData Halted command's data
      */
-    private _haltCommand;
+    protected _haltCommand(command: SlashCommandBuilder, haltData: SlashCommandHaltData): Promise<boolean>;
+    protected _haltCommand(command: MessageCommandBuilder, haltData: MessageCommandHaltData): Promise<boolean>;
+    /**
+     * Executes a command through a commandBuilder#execute method
+     * @param command Command builder
+     * @param executeData Command execute data
+     */
+    protected _executeCommand(command: SlashCommandBuilder, executeData: SlashCommandExecuteData): Promise<SlashCommandExecuteData | void>;
+    protected _executeCommand(command: MessageCommandBuilder, executeData: MessageCommandExecuteData): Promise<MessageCommandExecuteData | void>;
     /**
      * Error message when a command fails to execute
      * @param err Received error
      * @param command Slash/Message command execute data
      */
-    private _commandExecuteError;
+    protected _commandExecuteError(err: Error, command: AnyCommandExecuteData): Promise<void>;
 }

package/bin/reciple/classes/RecipleClient.js

@@ -15,8 +15,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
 const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
-const registerApplicationCommands_1 = require("../registerApplicationCommands");
 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");
@@ -26,9 +26,9 @@ const RecipleConfig_1 = require("./RecipleConfig");
 const modules_1 = require("../modules");
 const logger_1 = require("../logger");
 const version_1 = require("../version");
-const discord_js_1 = require("discord.js");
-const path_1 = __importDefault(require("path"));
 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 {
     /**
      * @param options Client options
@@ -146,11 +146,11 @@ class RecipleClient extends discord_js_1.Client {
      */
     addCommand(command) {
         var _a;
-        if (command.type === builders_1.CommandBuilderType.MessageCommand) {
-            this.commands.messageCommands[command.name] = command;
+        if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+            this.commands.slashCommands[command.name] = SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command);
         }
-        else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
-            this.commands.slashCommands[command.name] = 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 "${(_a = typeof command) !== null && _a !== void 0 ? _a : 'unknown'}".`);
@@ -213,17 +213,7 @@ class RecipleClient extends discord_js_1.Client {
                     }
                     return;
                 }
-                try {
-                    yield Promise.resolve(command.execute(executeData))
-                        .then(() => this.emit('recipleCommandExecute', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
-                    return executeData;
-                }
-                catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
-                        this._commandExecuteError(err, executeData);
-                    }
-                }
+                return this._executeCommand(command, executeData);
             }
             else if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.MissingMemberPermissions }))) {
                 yield interaction.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
@@ -297,17 +287,7 @@ class RecipleClient extends discord_js_1.Client {
                     }
                     return;
                 }
-                try {
-                    yield Promise.resolve(command.execute(executeData))
-                        .then(() => this.emit('recipleCommandExecute', executeData))
-                        .catch((err) => __awaiter(this, void 0, void 0, function* () { return (yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err })) ? this._commandExecuteError(err, executeData) : void 0; }));
-                    return executeData;
-                }
-                catch (err) {
-                    if (!(yield this._haltCommand(command, { executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
-                        this._commandExecuteError(err, executeData);
-                    }
-                }
+                return this._executeCommand(command, executeData);
             }
             else if (!(yield 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));
@@ -370,6 +350,27 @@ class RecipleClient extends discord_js_1.Client {
             }
         });
     }
+    _executeCommand(command, executeData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield Promise.resolve(command.type === builders_1.CommandBuilderType.SlashCommand
+                    ? command.execute(executeData)
+                    : command.execute(executeData))
+                    .then(() => this.emit('recipleCommandExecute', executeData))
+                    .catch((err) => __awaiter(this, void 0, void 0, function* () {
+                    return (yield this._haltCommand(command, { executeData: executeData, reason: commands_1.CommandHaltReason.Error, error: err }))
+                        ? this._commandExecuteError(err, executeData)
+                        : void 0;
+                }));
+                return executeData;
+            }
+            catch (err) {
+                if (!(yield this._haltCommand(command, { executeData: executeData, reason: commands_1.CommandHaltReason.Error, error: err }))) {
+                    this._commandExecuteError(err, executeData);
+                }
+            }
+        });
+    }
     /**
      * Error message when a command fails to execute
      * @param err Received error

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

@@ -80,11 +80,11 @@ export declare class RecipleConfig {
     /**
      * Check if the config version is supported
      */
-    private isSupportedConfig;
+    protected _isSupportedConfig(): boolean;
     /**
      * Ask for a token
      */
-    private askToken;
+    protected _askToken(): string | null;
     /**
      * Get default config
      */

package/bin/reciple/classes/RecipleConfig.js

@@ -39,7 +39,7 @@ class RecipleConfig {
                 throw new Error('Failed to create config file.');
             this.config = yaml_1.default.parse(defaultConfig);
             if (this.config && this.config.token === 'TOKEN') {
-                this.config.token = this.askToken() || this.config.token;
+                this.config.token = this._askToken() || this.config.token;
                 (0, fs_1.writeFileSync)(this.configPath, (0, fallout_utility_1.replaceAll)(defaultConfig, ' TOKEN', ` ${this.config.token}`), 'utf-8');
             }
             return this;
@@ -48,7 +48,7 @@ class RecipleConfig {
             throw new Error('Failed to read config file.');
         const config = (0, fs_1.readFileSync)(this.configPath, 'utf-8');
         this.config = yaml_1.default.parse(config);
-        if (!this.isSupportedConfig())
+        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);
         return this;
     }
@@ -69,24 +69,24 @@ class RecipleConfig {
         var _a;
         let token = flags_1.token || ((_a = this.config) === null || _a === void 0 ? void 0 : _a.token) || null;
         if (!token)
-            return token || (askIfNull ? this.askToken() : null);
+            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);
+        return token || (askIfNull ? this._askToken() : null);
     }
     /**
      * Check if the config version is supported
      */
-    isSupportedConfig() {
+    _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);
     }
     /**
      * Ask for a token
      */
-    askToken() {
+    _askToken() {
         return flags_1.token || (0, fallout_utility_1.input)({ text: 'Bot Token >>> ', echo: '*', repeatIfEmpty: true, sigint: true }) || null;
     }
     /**

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

@@ -1,6 +1,6 @@
-import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties } from '../../types/builders';
-import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
+import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, MessageCommandData } from '../../types/builders';
 import { Message, PermissionResolvable, RestOrArray } from 'discord.js';
+import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
 import { MessageCommandOptionManager } from '../MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Command as CommandMessage } from 'fallout-utility';
@@ -52,6 +52,7 @@ export declare class MessageCommandBuilder implements SharedCommandBuilderProper
     allowExecuteByBots: boolean;
     halt?: MessageCommandHaltFunction;
     execute: MessageCommandExecuteFunction;
+    constructor(data?: Partial<Omit<MessageCommandData, "type">>);
     /**
      * Sets the command name
      * @param name Command name
@@ -92,6 +93,11 @@ export declare class MessageCommandBuilder implements SharedCommandBuilderProper
     setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setHalt(halt?: MessageCommandHaltFunction | null): this;
     setExecute(execute: MessageCommandExecuteFunction): this;
+    /**
+     * Returns JSON object of this builder
+     */
+    toJSON(): MessageCommandData;
+    static resolveMessageCommand(commandData: MessageCommandData | MessageCommandBuilder): MessageCommandBuilder;
     /**
      * Is a message command builder
      */

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

@@ -18,7 +18,7 @@ const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
  * Reciple builder for message command
  */
 class MessageCommandBuilder {
-    constructor() {
+    constructor(data) {
         this.type = builders_1.CommandBuilderType.MessageCommand;
         this.name = '';
         this.description = '';
@@ -31,6 +31,30 @@ class MessageCommandBuilder {
         this.allowExecuteInDM = true;
         this.allowExecuteByBots = false;
         this.execute = () => { };
+        if ((data === null || data === void 0 ? void 0 : data.name) !== undefined)
+            this.setName(data.name);
+        if ((data === null || data === void 0 ? void 0 : data.description) !== undefined)
+            this.setDescription(data.description);
+        if ((data === null || data === void 0 ? void 0 : data.cooldown) !== undefined)
+            this.setCooldown(Number(data === null || data === void 0 ? void 0 : data.cooldown));
+        if ((data === null || data === void 0 ? void 0 : data.requiredBotPermissions) !== undefined)
+            this.setRequiredBotPermissions(data.requiredBotPermissions);
+        if ((data === null || data === void 0 ? void 0 : data.requiredMemberPermissions) !== undefined)
+            this.setRequiredMemberPermissions(data.requiredMemberPermissions);
+        if ((data === null || data === void 0 ? void 0 : data.halt) !== undefined)
+            this.setHalt(this.halt);
+        if ((data === null || data === void 0 ? void 0 : data.execute) !== undefined)
+            this.setExecute(data.execute);
+        if ((data === null || data === void 0 ? void 0 : data.aliases) !== undefined)
+            this.addAliases(data.aliases);
+        if (data === null || data === void 0 ? void 0 : data.allowExecuteByBots)
+            this.setAllowExecuteByBots(true);
+        if (data === null || data === void 0 ? void 0 : data.allowExecuteInDM)
+            this.setAllowExecuteInDM(true);
+        if (data === null || data === void 0 ? void 0 : data.validateOptions)
+            this.setValidateOptions(true);
+        if ((data === null || data === void 0 ? void 0 : data.options) !== undefined)
+            this.options = data.options.map(o => o instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder(o));
     }
     /**
      * Sets the command name
@@ -134,6 +158,29 @@ class MessageCommandBuilder {
         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
      */

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

@@ -1,3 +1,4 @@
+import { MessageCommandOptionData } from '../../types/builders';
 import { Awaitable } from 'discord.js';
 /**
  * Option builder for MessageCommandBuilder
@@ -7,6 +8,7 @@ export declare class MessageCommandOptionBuilder {
     description: string;
     required: boolean;
     validator: (value: string) => Awaitable<boolean>;
+    constructor(data?: Partial<MessageCommandOptionData>);
     /**
      * Set command option name
      * @param name Option name
@@ -27,4 +29,5 @@ export declare class MessageCommandOptionBuilder {
      * @param validator Custom function to validate value given for this option
      */
     setValidator(validator: (value: string) => Awaitable<boolean>): this;
+    toJSON(): MessageCommandOptionData;
 }

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

@@ -5,11 +5,19 @@ exports.MessageCommandOptionBuilder = void 0;
  * Option builder for MessageCommandBuilder
  */
 class MessageCommandOptionBuilder {
-    constructor() {
+    constructor(data) {
         this.name = '';
         this.description = '';
         this.required = false;
         this.validator = () => true;
+        if ((data === null || data === void 0 ? void 0 : data.name) !== undefined)
+            this.setName(data.name);
+        if ((data === null || data === void 0 ? void 0 : data.description) !== undefined)
+            this.setDescription(data.description);
+        if ((data === null || data === void 0 ? void 0 : data.required) !== undefined)
+            this.setRequired(data.required);
+        if ((data === null || data === void 0 ? void 0 : data.validator) !== undefined)
+            this.setValidator(data.validator);
     }
     /**
      * Set command option name
@@ -51,5 +59,13 @@ class MessageCommandOptionBuilder {
         this.validator = validator;
         return this;
     }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            required: this.required,
+            validator: this.validator,
+        };
+    }
 }
 exports.MessageCommandOptionBuilder = MessageCommandOptionBuilder;

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

@@ -1,6 +1,6 @@
-import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, AnySlashCommandBuilder } from '../../types/builders';
+import { CommandBuilderType, CommandHaltFunction, CommandExecuteFunction, SharedCommandBuilderProperties, AnySlashCommandBuilder, SlashCommandData, AnySlashCommandOptionData, AnySlashCommandOptionBuilder } from '../../types/builders';
 import { BaseCommandExecuteData, CommandHaltData } from '../../types/commands';
-import { ChatInputCommandInteraction, PermissionResolvable, RestOrArray, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandAttachmentOption, SlashCommandMentionableOption, SlashCommandStringOption, SlashCommandIntegerOption, SlashCommandNumberOption } from 'discord.js';
+import { ChatInputCommandInteraction, PermissionResolvable, RestOrArray, SlashCommandBuilder as DiscordJsSlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandBooleanOption, SlashCommandUserOption, SlashCommandChannelOption, SlashCommandRoleOption, SlashCommandAttachmentOption, SlashCommandMentionableOption, SlashCommandStringOption, SlashCommandIntegerOption, SlashCommandNumberOption, SharedSlashCommandOptions } from 'discord.js';
 /**
  * Execute data for slash command
  */
@@ -45,15 +45,25 @@ export declare class SlashCommandBuilder extends DiscordJsSlashCommandBuilder im
     requiredMemberPermissions: PermissionResolvable[];
     halt?: SlashCommandHaltFunction;
     execute: SlashCommandExecuteFunction;
+    constructor(data?: Partial<Omit<SlashCommandData, "type">>);
     setCooldown(cooldown: number): this;
     setRequiredBotPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setRequiredMemberPermissions(...permissions: RestOrArray<PermissionResolvable>): this;
     setHalt(halt?: SlashCommandHaltFunction | null): this;
     setExecute(execute: SlashCommandExecuteFunction): this;
+    /**
+     * Add option builder to command builder
+     */
+    static addOption(builder: SharedSlashCommandOptions | SlashCommandBuilder, option: AnySlashCommandOptionBuilder): SharedSlashCommandOptions;
+    /**
+     * Resolve option data
+     */
+    static resolveOption<T extends AnySlashCommandOptionBuilder>(option: AnySlashCommandOptionData): T;
+    static resolveSlashCommand(commandData: SlashCommandData | AnySlashCommandBuilder): AnySlashCommandBuilder;
     /**
      * Is a slash command builder
      */
-    static isSlashCommandBuilder(builder: unknown): builder is SlashCommandBuilder;
+    static isSlashCommandBuilder(builder: unknown): builder is AnySlashCommandBuilder;
     /**
      * Is a slash command execute data
      */

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

@@ -2,18 +2,48 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlashCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
+const util_1 = require("../../util");
 const discord_js_1 = require("discord.js");
 /**
  * Reciple builder for slash command
  */
 class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
-    constructor() {
-        super(...arguments);
+    constructor(data) {
+        super();
         this.type = builders_1.CommandBuilderType.SlashCommand;
         this.cooldown = 0;
         this.requiredBotPermissions = [];
         this.requiredMemberPermissions = [];
         this.execute = () => { };
+        if ((data === null || data === void 0 ? void 0 : data.name) !== undefined)
+            this.setName(data.name);
+        if ((data === null || data === void 0 ? void 0 : data.description) !== undefined)
+            this.setDescription(data.description);
+        if ((data === null || data === void 0 ? void 0 : data.cooldown) !== undefined)
+            this.setCooldown(Number(data === null || data === void 0 ? void 0 : data.cooldown));
+        if ((data === null || data === void 0 ? void 0 : data.requiredBotPermissions) !== undefined)
+            this.setRequiredBotPermissions(data.requiredBotPermissions);
+        if ((data === null || data === void 0 ? void 0 : data.requiredMemberPermissions) !== undefined)
+            this.setRequiredMemberPermissions(data.requiredMemberPermissions);
+        if ((data === null || data === void 0 ? void 0 : data.halt) !== undefined)
+            this.setHalt(this.halt);
+        if ((data === null || data === void 0 ? void 0 : data.execute) !== undefined)
+            this.setExecute(data.execute);
+        if ((data === null || data === void 0 ? void 0 : data.nameLocalizations) !== undefined)
+            this.setNameLocalizations(data.nameLocalizations);
+        if ((data === null || data === void 0 ? void 0 : data.descriptionLocalizations) !== undefined)
+            this.setDescriptionLocalizations(data.descriptionLocalizations);
+        if ((data === null || data === void 0 ? void 0 : data.defaultMemberPermissions) !== undefined)
+            this.setDefaultMemberPermissions(data.defaultMemberPermissions);
+        if (data === null || data === void 0 ? void 0 : data.dmPermission)
+            this.setDMPermission(true);
+        if (data === null || data === void 0 ? void 0 : data.defaultPermission)
+            this.setDefaultPermission(true);
+        if (data === null || data === void 0 ? void 0 : data.options) {
+            for (const option of data.options) {
+                SlashCommandBuilder.addOption(this, (0, util_1.isClass)(option) ? option : SlashCommandBuilder.resolveOption(option));
+            }
+        }
     }
     setCooldown(cooldown) {
         this.cooldown = cooldown;
@@ -37,6 +67,131 @@ class SlashCommandBuilder extends discord_js_1.SlashCommandBuilder {
         this.execute = execute;
         return this;
     }
+    /**
+     * Add option builder to command builder
+     */
+    static addOption(builder, option) {
+        if (option instanceof discord_js_1.SlashCommandAttachmentOption) {
+            builder.addAttachmentOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandBooleanOption) {
+            builder.addBooleanOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandChannelOption) {
+            builder.addChannelOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandIntegerOption) {
+            builder.addIntegerOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandMentionableOption) {
+            builder.addMentionableOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandNumberOption) {
+            builder.addNumberOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandRoleOption) {
+            builder.addRoleOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandStringOption) {
+            builder.addStringOption(option);
+        }
+        else if (option instanceof discord_js_1.SlashCommandUserOption) {
+            builder.addUserOption(option);
+        }
+        else if (builder instanceof SlashCommandBuilder) {
+            if (option instanceof discord_js_1.SlashCommandSubcommandBuilder) {
+                builder.addSubcommand(option);
+            }
+            else if (option instanceof discord_js_1.SlashCommandSubcommandGroupBuilder) {
+                builder.addSubcommandGroup(option);
+            }
+        }
+        return builder;
+    }
+    /**
+     * Resolve option data
+     */
+    static resolveOption(option) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        let builder;
+        switch (option.type) {
+            case discord_js_1.ApplicationCommandOptionType.Attachment:
+                builder = new discord_js_1.SlashCommandAttachmentOption();
+                break;
+            case discord_js_1.ApplicationCommandOptionType.Boolean:
+                builder = new discord_js_1.SlashCommandBooleanOption();
+                break;
+            case discord_js_1.ApplicationCommandOptionType.Channel:
+                builder = new discord_js_1.SlashCommandChannelOption()
+                    .addChannelTypes(...((_a = option.channelTypes) !== null && _a !== void 0 ? _a : []));
+                break;
+            case discord_js_1.ApplicationCommandOptionType.Integer:
+                builder = new discord_js_1.SlashCommandIntegerOption()
+                    .addChoices(...((_b = option.choices) !== null && _b !== void 0 ? _b : []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxValue)
+                    builder.setMaxValue(option.maxValue);
+                if (option.minValue)
+                    builder.setMinValue(option.minValue);
+                break;
+            case discord_js_1.ApplicationCommandOptionType.Mentionable:
+                builder = new discord_js_1.SlashCommandMentionableOption();
+                break;
+            case discord_js_1.ApplicationCommandOptionType.Number:
+                builder = new discord_js_1.SlashCommandNumberOption()
+                    .addChoices(...((_c = option.choices) !== null && _c !== void 0 ? _c : []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxValue)
+                    builder.setMaxValue(option.maxValue);
+                if (option.minValue)
+                    builder.setMinValue(option.minValue);
+                break;
+            case discord_js_1.ApplicationCommandOptionType.Role:
+                builder = new discord_js_1.SlashCommandRoleOption();
+                break;
+            case discord_js_1.ApplicationCommandOptionType.String:
+                builder = new discord_js_1.SlashCommandStringOption()
+                    .addChoices(...((_d = option.choices) !== null && _d !== void 0 ? _d : []))
+                    .setAutocomplete(!!option.autocomplete);
+                if (option.maxLength)
+                    builder.setMaxLength(option.maxLength);
+                if (option.minLength)
+                    builder.setMinLength(option.minLength);
+                break;
+            case discord_js_1.ApplicationCommandOptionType.User:
+                builder = new discord_js_1.SlashCommandUserOption();
+                break;
+            case discord_js_1.ApplicationCommandOptionType.Subcommand:
+                builder = new discord_js_1.SlashCommandSubcommandBuilder();
+                for (const optionData of option.options) {
+                    this.addOption(builder, this.resolveOption(optionData));
+                }
+                break;
+            case discord_js_1.ApplicationCommandOptionType.SubcommandGroup:
+                builder = new discord_js_1.SlashCommandSubcommandGroupBuilder();
+                for (const subCommandData of option.options) {
+                    builder.addSubcommand(subCommandData instanceof discord_js_1.SlashCommandSubcommandBuilder
+                        ? subCommandData
+                        : this.resolveOption(subCommandData));
+                }
+                break;
+            default:
+                throw new TypeError("Unknown option data");
+        }
+        if (!(builder instanceof discord_js_1.SlashCommandSubcommandBuilder) && !(builder instanceof discord_js_1.SlashCommandSubcommandGroupBuilder)
+            &&
+                option.type !== discord_js_1.ApplicationCommandOptionType.Subcommand && option.type !== discord_js_1.ApplicationCommandOptionType.SubcommandGroup) {
+            builder.setRequired((_e = option.required) !== null && _e !== void 0 ? _e : false);
+        }
+        return builder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setNameLocalizations((_f = option.nameLocalizations) !== null && _f !== void 0 ? _f : null)
+            .setDescriptionLocalizations((_g = option.descriptionLocalizations) !== null && _g !== void 0 ? _g : null);
+    }
+    static resolveSlashCommand(commandData) {
+        return this.isSlashCommandBuilder(commandData) ? commandData : new SlashCommandBuilder(commandData);
+    }
     /**
      * Is a slash command builder
      */

package/bin/reciple/modules.d.ts

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

package/bin/reciple/modules.js

@@ -14,6 +14,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModules = void 0;
 const builders_1 = require("./types/builders");
+const MessageCommandBuilder_1 = require("./classes/builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("./classes/builders/SlashCommandBuilder");
 const discord_js_1 = require("discord.js");
 const version_1 = require("./version");
 const fs_1 = require("fs");
@@ -52,8 +54,11 @@ function getModules(client, folder) {
                     throw new Error(script + ' onStart returned false or undefined.');
                 if (module_.commands) {
                     for (const command of module_.commands) {
-                        if (command.type === builders_1.CommandBuilderType.MessageCommand || command.type === builders_1.CommandBuilderType.SlashCommand) {
-                            commands.push(command);
+                        if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+                            commands.push(MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
+                        }
+                        else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+                            commands.push(SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
                         }
                     }
                 }

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

@@ -1,10 +1,15 @@
-import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandExecuteFunction, MessageCommandHaltData, MessageCommandHaltFunction } from '../classes/builders/MessageCommandBuilder';
+import { ApplicationCommandOptionAllowedChannelTypes, ApplicationCommandOptionType, Awaitable, LocalizationMap, PermissionResolvable, RestOrArray, SlashCommandAttachmentOption, SlashCommandBooleanOption, SlashCommandChannelOption, SlashCommandIntegerOption, SlashCommandMentionableOption, SlashCommandNumberOption, SlashCommandRoleOption, SlashCommandStringOption, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandUserOption } from 'discord.js';
 import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandExecuteFunction, SlashCommandHaltData, SlashCommandHaltFunction, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandsOnlyBuilder } from '../classes/builders/SlashCommandBuilder';
-import { Awaitable, PermissionResolvable, RestOrArray } from 'discord.js';
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandExecuteFunction, MessageCommandHaltData, MessageCommandHaltFunction } from '../classes/builders/MessageCommandBuilder';
+import { MessageCommandOptionBuilder } from '../classes/builders/MessageCommandOptionBuilder';
 /**
  * Any command builders
  */
 export declare type AnyCommandBuilder = AnySlashCommandBuilder | MessageCommandBuilder;
+/**
+ * Any command data
+ */
+export declare type AnyCommandData = SlashCommandData | MessageCommandData;
 /**
  * Any slash command builders
  */
@@ -18,13 +23,33 @@ export declare type AnyCommandHaltFunction = SlashCommandHaltFunction | MessageC
  */
 export declare type AnyCommandExecuteFunction = SlashCommandExecuteFunction | MessageCommandExecuteFunction;
 /**
- * command halt function
+ * Command halt function
  */
 export declare type CommandHaltFunction<T extends CommandBuilderType> = (haltData: T extends CommandBuilderType.SlashCommand ? SlashCommandHaltData : MessageCommandHaltData) => Awaitable<boolean | null | undefined | void>;
 /**
- * command execute function
+ * Command execute function
  */
 export declare type CommandExecuteFunction<T extends CommandBuilderType> = (executeData: T extends CommandBuilderType.SlashCommand ? SlashCommandExecuteData : MessageCommandExecuteData) => Awaitable<void>;
+/**
+ * Message command options resolvable
+ */
+export declare type MessageCommandOptionResolvable = MessageCommandOptionBuilder | MessageCommandOptionData;
+/**
+ * Slash command options
+ */
+export declare type AnySlashCommandOptionData = AnySlashCommandOptionsOnlyOptionData | SlashCommandSubCommandGroupData | SlashCommandSubCommandData;
+/**
+ * Slash command options builders
+ */
+export declare type AnySlashCommandOptionBuilder = AnySlashCommandOptionsOnlyOptionBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandBuilder;
+/**
+ * Slash command options without sub commands
+ */
+export declare type AnySlashCommandOptionsOnlyOptionData = SlashCommandStringOptionData | SlashCommandNumberOptionData | SlashCommandIntegerOptionData | SlashCommandBooleanOptionData | SlashCommandMentionableOptionData | SlashCommandRoleOptionData | SlashCommandUserOptionData | SlashCommandAttachmentOptionData | SlashCommandChannelOptionData;
+/**
+ * Slash command option builder without sub commands
+ */
+export declare type AnySlashCommandOptionsOnlyOptionBuilder = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption | SlashCommandBooleanOption | SlashCommandMentionableOption | SlashCommandRoleOption | SlashCommandUserOption | SlashCommandAttachmentOption | SlashCommandChannelOption;
 /**
  * Types of command builders
  */
@@ -33,7 +58,7 @@ export declare enum CommandBuilderType {
     SlashCommand = 1
 }
 /**
- * Shared command builder methods
+ * Shared command builder methods and properties
  */
 export interface SharedCommandBuilderProperties {
     readonly type: CommandBuilderType;
@@ -69,3 +94,100 @@ export interface SharedCommandBuilderProperties {
      */
     setExecute(execute: this["execute"]): this;
 }
+/**
+ * Shared command name and description properties
+ */
+export interface SharedCommandDataProperties {
+    name: string;
+    description: string;
+}
+/**
+ * Slash command object data interface
+ */
+export interface SlashCommandData extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "halt" | "execute">> {
+    type: CommandBuilderType.SlashCommand;
+    nameLocalizations?: LocalizationMap;
+    descriptionLocalizations?: LocalizationMap;
+    options: (AnySlashCommandOptionData | AnySlashCommandOptionBuilder)[];
+    /**
+     * @deprecated This property is deprecated and will be removed in the future.
+     */
+    defaultPermission?: boolean;
+    defaultMemberPermissions?: string | null;
+    dmPermission?: boolean;
+    halt?: SlashCommandHaltFunction;
+    execute: SlashCommandExecuteFunction;
+}
+export interface SharedSlashCommandOptionData<V = string | number> extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+    choices?: {
+        name: string;
+        nameLocalizations?: LocalizationMap;
+        value: V;
+    }[];
+    autocomplete?: boolean;
+    required?: boolean;
+}
+export interface SlashCommandAttachmentOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+    type: ApplicationCommandOptionType.Attachment;
+}
+export interface SlashCommandBooleanOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+    type: ApplicationCommandOptionType.Boolean;
+}
+export interface SlashCommandChannelOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+    type: ApplicationCommandOptionType.Channel;
+    channelTypes?: ApplicationCommandOptionAllowedChannelTypes[];
+}
+export interface SlashCommandIntegerOptionData extends SharedSlashCommandOptionData<number> {
+    type: ApplicationCommandOptionType.Integer;
+    minValue?: number;
+    maxValue?: number;
+}
+export interface SlashCommandMentionableOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+    type: ApplicationCommandOptionType.Mentionable;
+}
+export interface SlashCommandNumberOptionData extends SharedSlashCommandOptionData<number> {
+    type: ApplicationCommandOptionType.Number;
+    minValue?: number;
+    maxValue?: number;
+}
+export interface SlashCommandRoleOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+    type: ApplicationCommandOptionType.Role;
+}
+export interface SlashCommandStringOptionData extends SharedSlashCommandOptionData<string> {
+    type: ApplicationCommandOptionType.String;
+    minLength?: number;
+    maxLength?: number;
+}
+export interface SlashCommandUserOptionData extends Omit<SharedSlashCommandOptionData, "choices" | "autocomplete"> {
+    type: ApplicationCommandOptionType.User;
+}
+export interface SlashCommandSubCommandData extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+    type: ApplicationCommandOptionType.Subcommand;
+    options: (AnySlashCommandOptionsOnlyOptionData | AnySlashCommandOptionsOnlyOptionBuilder)[];
+}
+export interface SlashCommandSubCommandGroupData extends SharedCommandDataProperties, Pick<SlashCommandData, "nameLocalizations" | "descriptionLocalizations"> {
+    type: ApplicationCommandOptionType.SubcommandGroup;
+    options: (SlashCommandSubCommandData | SlashCommandSubcommandBuilder)[];
+}
+/**
+ * Message command object data interface
+ */
+export interface MessageCommandData extends SharedCommandDataProperties, Partial<Omit<SharedCommandBuilderProperties, "setCooldown" | "setRequiredBotPermissions" | "setRequiredMemberPermissions" | "setHalt" | "setExecute" | "halt" | "execute">> {
+    type: CommandBuilderType.MessageCommand;
+    aliases?: string[];
+    validateOptions?: boolean;
+    allowExecuteInDM?: boolean;
+    allowExecuteByBots?: boolean;
+    halt?: MessageCommandHaltFunction;
+    execute: MessageCommandExecuteFunction;
+    options: MessageCommandOptionResolvable[];
+}
+/**
+ * Message command option object data interface
+ */
+export interface MessageCommandOptionData extends SharedCommandDataProperties {
+    name: string;
+    description: string;
+    required: boolean;
+    validator: (value: string) => Awaitable<boolean>;
+}

package/bin/reciple/util.d.ts

@@ -0,0 +1 @@
+export declare function isClass<T extends any>(object: any): object is T;

package/bin/reciple/util.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClass = void 0;
+function isClass(object) {
+    const isClassConstructor = object.constructor && object.constructor.toString().substring(0, 5) === 'class';
+    if (object.prototype === undefined)
+        return isClassConstructor;
+    const isPrototypeClassConstructor = object.prototype.constructor && object.prototype.constructor.toString && object.prototype.constructor.toString().substring(0, 5) === 'class';
+    return isClassConstructor || isPrototypeClassConstructor;
+}
+exports.isClass = isClass;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "bin": "bin/bin.js",
   "license": "GPL-3.0",
   "main": "bin/index.js",