reciple 5.6.0 → 6.0.0-dev.1

package/dist/cjs/bin.js

@@ -12,7 +12,6 @@ const flags_1 = require("./reciple/flags");
 const fallout_utility_1 = require("fallout-utility");
 const chalk_1 = __importDefault(require("chalk"));
 require("dotenv/config");
-const discord_js_1 = require("discord.js");
 const path_1 = __importDefault(require("path"));
 const allowedFiles = ['node_modules', 'reciple.yml', 'package.json'];
 const configPath = path_1.default.join(flags_1.cwd, './reciple.yml');
@@ -34,15 +33,15 @@ const client = new RecipleClient_1.RecipleClient({ config: config, ...config.cli
 if (config.fileLogging.clientLogs)
     client.logger.info('Starting Reciple client v' + version_1.rawVersion);
 (async () => {
-    await client.startModules((0, discord_js_1.normalizeArray)([config.modulesFolder]));
+    client.addCommandListeners();
+    await client.modules.startModulesFromFiles({
+        files: await client.modules.getModuleFiles()
+    });
     client.on('ready', async () => {
+        await client.modules.loadAll(true);
         if (client.isClientLogsEnabled())
             client.logger.warn(`Logged in as ${client.user?.tag || 'Unknown'}!`);
-        client.on('cacheSweep', () => {
-            client.cooldowns.clean();
-        });
-        await client.loadModules();
-        client.addCommandListeners();
+        client.on('cacheSweep', () => client.cooldowns.clean());
     });
     client.login(config.token).catch(err => {
         if (client.isClientLogsEnabled())

package/dist/cjs/index.js

@@ -14,13 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./reciple/classes/CommandCooldownManager"), exports);
-__exportStar(require("./reciple/classes/MessageCommandOptionManager"), exports);
-__exportStar(require("./reciple/classes/RecipleClient"), exports);
-__exportStar(require("./reciple/classes/RecipleConfig"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/SlashCommandBuilder"), exports);
+__exportStar(require("./reciple/classes/managers/ApplicationCommandManager"), exports);
+__exportStar(require("./reciple/classes/managers/CommandCooldownManager"), exports);
+__exportStar(require("./reciple/classes/managers/ClientCommandManager"), exports);
+__exportStar(require("./reciple/classes/managers/MessageCommandOptionManager"), exports);
+__exportStar(require("./reciple/classes/RecipleClient"), exports);
+__exportStar(require("./reciple/classes/RecipleConfig"), exports);
 __exportStar(require("./reciple/types/builders"), exports);
 __exportStar(require("./reciple/types/commands"), exports);
 __exportStar(require("./reciple/types/paramOptions"), exports);
@@ -28,6 +30,5 @@ __exportStar(require("./reciple/flags"), exports);
 __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/dist/cjs/reciple/classes/RecipleClient.js

@@ -6,21 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecipleClient = void 0;
 const MessageCommandBuilder_1 = require("./builders/MessageCommandBuilder");
 const SlashCommandBuilder_1 = require("./builders/SlashCommandBuilder");
-const builders_1 = require("../types/builders");
-const registerApplicationCommands_1 = require("../registerApplicationCommands");
 const commands_1 = require("../types/commands");
+const CommandCooldownManager_1 = require("./managers/CommandCooldownManager");
 const permissions_1 = require("../permissions");
-const CommandCooldownManager_1 = require("./CommandCooldownManager");
-const MessageCommandOptionManager_1 = require("./MessageCommandOptionManager");
+const MessageCommandOptionManager_1 = require("./managers/MessageCommandOptionManager");
+const ApplicationCommandManager_1 = require("./managers/ApplicationCommandManager");
+const builders_1 = require("../types/builders");
+const ClientCommandManager_1 = require("./managers/ClientCommandManager");
 const RecipleConfig_1 = require("./RecipleConfig");
-const modules_1 = require("../modules");
 const fallout_utility_1 = require("fallout-utility");
 const logger_1 = require("../logger");
 const version_1 = require("../version");
 const flags_1 = require("../flags");
 const path_1 = __importDefault(require("path"));
 const discord_js_1 = require("discord.js");
-const util_1 = require("../util");
+const ClientModuleManager_1 = require("./managers/ClientModuleManager");
 class RecipleClient extends discord_js_1.Client {
     /**
      * @param options Client options
@@ -28,126 +28,15 @@ class RecipleClient extends discord_js_1.Client {
     constructor(options) {
         super(options);
         this.config = RecipleConfig_1.RecipleConfig.getDefaultConfig();
-        this.commands = { slashCommands: new discord_js_1.Collection(), messageCommands: new discord_js_1.Collection() };
-        this.additionalApplicationCommands = [];
+        this.commands = new ClientCommandManager_1.ClientCommandManager({ client: this });
         this.cooldowns = new CommandCooldownManager_1.CommandCooldownManager();
-        this.modules = [];
+        this.modules = new ClientModuleManager_1.ClientModuleManager({ client: this });
         this.version = version_1.version;
         this.logger = (0, logger_1.createLogger)(!!options.config?.fileLogging.stringifyLoggedJSON, options.config?.fileLogging.debugmode);
         this.config = { ...this.config, ...(options.config ?? {}) };
         if (this.config.fileLogging.enabled)
             this.logger.logFile(path_1.default.join(flags_1.cwd, this.config.fileLogging.logFilePath ?? 'logs/latest.log'), false);
-    }
-    /**
-     * Load and start modules from given folders
-     * @param folders folders that contains the modules you want to load
-     */
-    async startModules(...folders) {
-        folders = (0, discord_js_1.normalizeArray)(folders).map(f => path_1.default.join(flags_1.cwd, f));
-        for (const folder of folders) {
-            if (this.isClientLogsEnabled())
-                this.logger.info(`Loading Modules from ${folder}`);
-            const modules = await (0, modules_1.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 {@link RecipleModule['onLoad']} from client modules and register application commands if enabled
-     */
-    async loadModules() {
-        if (!this.isReady())
-            throw new Error('Client is not ready');
-        for (const m in this.modules) {
-            const index = (m);
-            const module_ = this.modules[index];
-            try {
-                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.splice(index);
-                    });
-                }
-            }
-            catch (err) {
-                if (this.isClientLogsEnabled()) {
-                    this.logger.error(`Error loading ${module_.info.filename ?? 'unknown module'}:`);
-                    this.logger.error(err);
-                }
-                this.modules.splice(index);
-            }
-            if (module_.script?.commands && Array.isArray(module_.script?.commands)) {
-                for (const command of module_.script.commands) {
-                    this.addCommand(command);
-                }
-            }
-        }
-        if (this.isClientLogsEnabled()) {
-            this.logger.info(`${this.modules.length} modules loaded.`);
-            this.logger.info(`${this.commands.messageCommands.size} message commands loaded.`);
-            this.logger.info(`${this.commands.slashCommands.size} slash commands loaded.`);
-        }
-        if (this.config.commands.slashCommand.registerCommands)
-            await this.registerClientApplicationCommands();
-        return this;
-    }
-    /**
-     * Add module
-     * @param options Module options
-     * @deprecated This is very stupid, Just add it manually
-     */
-    async addModule(options) {
-        (0, util_1.deprecationWarning)('Add modules manually It\'s not that hard');
-        // TODO: DEPRECATED!
-        const { script } = options;
-        const registerCommands = options.registerApplicationCommands;
-        const info = options.moduleInfo;
-        if (!this.isReady())
-            throw new Error('Client is not ready');
-        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 this.registerClientApplicationCommands();
-    }
-    /**
-     * Add slash or message command to client
-     * @param command Slash/Message command builder
-     */
-    addCommand(command) {
-        if (command.type === builders_1.CommandBuilderType.SlashCommand) {
-            this.commands.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
-        }
-        else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
-            this.commands.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
-        }
-        else if (this.isClientLogsEnabled()) {
-            this.logger.error(`Unknow command "${typeof command ?? 'unknown'}".`);
-        }
-        return this;
+        this.applicationCommands = new ApplicationCommandManager_1.ApplicationCommandManager(this);
     }
     /**
      * Listed to command executions
@@ -172,7 +61,7 @@ class RecipleClient extends discord_js_1.Client {
             return;
         if (!this.config.commands.slashCommand.acceptRepliedInteractions && (interaction.replied || interaction.deferred))
             return;
-        const command = this.findCommand(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
+        const command = this.commands.get(interaction.commandName, builders_1.CommandBuilderType.SlashCommand);
         if (!command)
             return;
         const executeData = {
@@ -226,7 +115,7 @@ class RecipleClient extends discord_js_1.Client {
         const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.commands.messageCommand.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
         if (!parseCommand || !parseCommand?.command)
             return;
-        const command = this.findCommand(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
+        const command = this.commands.get(parseCommand.command, builders_1.CommandBuilderType.MessageCommand);
         if (!command)
             return;
         const commandOptions = await (0, MessageCommandBuilder_1.validateMessageCommandOptions)(command, parseCommand);
@@ -286,17 +175,6 @@ class RecipleClient extends discord_js_1.Client {
             message.reply(this.getConfigMessage('noPermissions', 'You do not have permission to use this command.')).catch(er => this._replyError(er));
         }
     }
-    /**
-     * Registers client slash commands and other application commands
-     */
-    async registerClientApplicationCommands() {
-        await (0, registerApplicationCommands_1.registerApplicationCommands)({
-            client: this,
-            commands: [...this.commands.slashCommands.toJSON(), ...this.additionalApplicationCommands],
-            guilds: this.config.commands.slashCommand.guilds
-        });
-        this.emit('recipleRegisterApplicationCommands');
-    }
     /**
      * Get a message from config
      * @param messageKey Config messages key
@@ -305,19 +183,6 @@ class RecipleClient extends discord_js_1.Client {
     getConfigMessage(messageKey, defaultMessage) {
         return this.config.messages[messageKey] ?? defaultMessage ?? messageKey;
     }
-    findCommand(command, type) {
-        switch (type) {
-            case builders_1.CommandBuilderType.SlashCommand:
-                return this.commands.slashCommands.get(command);
-            case builders_1.CommandBuilderType.MessageCommand:
-                return this.commands.messageCommands.get(command.toLowerCase())
-                    ?? (this.config.commands.messageCommand.allowCommandAlias
-                        ? 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
      */

package/dist/cjs/reciple/classes/builders/MessageCommandBuilder.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
 const builders_1 = require("../../types/builders");
 const discord_js_1 = require("discord.js");
-const MessageCommandOptionManager_1 = require("../MessageCommandOptionManager");
+const MessageCommandOptionManager_1 = require("../managers/MessageCommandOptionManager");
 const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
 /**
  * Reciple builder for message command

package/dist/cjs/reciple/classes/managers/ApplicationCommandManager.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationCommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ApplicationCommandManager {
+    constructor(client) {
+        this.client = client;
+    }
+    get commands() { return this.client.application?.commands; }
+    async set(commands, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.set(commands, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.set(commands);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) globally...`);
+        }
+        else {
+            this.client.application.commands.set(commands, guild);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) to guild ${guild}...`);
+        }
+    }
+    async add(command, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (!command)
+            throw new Error('Command is undefined');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.add(command, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.create(command);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Created application command '${command.name}' globally`);
+        }
+        else {
+            this.client.application.commands.create(command, guild);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Created application command '${command.name}' to guild ${guild}`);
+        }
+    }
+    async remove(command, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (!command)
+            throw new Error('Command is undefined');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.remove(command, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.delete(command);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
+        }
+        else {
+            this.client.application.commands.delete(command, guild);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
+        }
+    }
+    async edit(command, newCommand, guilds) {
+        if (!this.client.isReady())
+            throw new Error('Client is not ready');
+        if (!command)
+            throw new Error('Command is undefined');
+        if (guilds && guilds.length > 1) {
+            for (const guild of guilds) {
+                await this.edit(command, newCommand, [guild]);
+            }
+            return;
+        }
+        let guild = guilds?.shift();
+        guild = guild ? this.client.guilds.resolveId(guild) || undefined : undefined;
+        if (!guild) {
+            this.client.application.commands.edit(command, newCommand);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
+        }
+        else {
+            this.client.application.commands.edit(command, newCommand, guild);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
+        }
+    }
+    get(command, guild) {
+        const commands = guild ? this.client.guilds.resolve(guild)?.commands.cache : this.client.application?.commands.cache;
+        if (!commands)
+            throw new Error('Guild not found in cache');
+        return commands.find(cmd => typeof command === 'string'
+            ? (cmd.id === command || cmd.name === command)
+            : (cmd.name === command.name || (command instanceof discord_js_1.ApplicationCommand && cmd.id === command.id)));
+    }
+    async fetch(commandId, guild) {
+        const manager = guild ? this.client.guilds.resolve(guild)?.commands : this.client.application?.commands;
+        if (!manager)
+            throw new Error('Guild not found in cache');
+        return manager.fetch(commandId);
+    }
+    parseCommands(commands, setPermissions = true) {
+        return commands.map(cmd => {
+            if (cmd?.toJSON === undefined)
+                return (cmd);
+            if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandBuilder(cmd) && this.client.config.commands.slashCommand.setRequiredPermissions) {
+                const permissions = (setPermissions || this.client.config.commands.slashCommand.permissions.enabled)
+                    ? this.client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions
+                    : undefined;
+                if (permissions) {
+                    cmd.setRequiredMemberPermissions(...permissions);
+                    if (this.client.isClientLogsEnabled())
+                        this.client.logger.debug(`Set required permissions for ${cmd.name}`);
+                }
+            }
+            return cmd.toJSON();
+        });
+    }
+}
+exports.ApplicationCommandManager = ApplicationCommandManager;

package/dist/cjs/reciple/classes/managers/ClientCommandManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientCommandManager = void 0;
+const discord_js_1 = require("discord.js");
+const builders_1 = require("../../types/builders");
+const MessageCommandBuilder_1 = require("../builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ClientCommandManager {
+    constructor(options) {
+        this.slashCommands = new discord_js_1.Collection();
+        this.messageCommands = new discord_js_1.Collection();
+        this.additionalApplicationCommands = [];
+        this.client = options.client;
+        options.slashCommands?.forEach(e => this.slashCommands.set(e.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(e)));
+        options.messageCommands?.forEach(e => this.messageCommands.set(e.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(e)));
+    }
+    get applicationCommandsSize() { return this.client.commands.slashCommands.size + this.client.commands.additionalApplicationCommands.length; }
+    /**
+     * Add command to command manager
+     * @param commands Any command data or builder
+     */
+    add(...commands) {
+        for (const command of (0, discord_js_1.normalizeArray)(commands)) {
+            if (command.type === builders_1.CommandBuilderType.SlashCommand) {
+                this.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
+            }
+            else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+                this.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
+            }
+        }
+        return this;
+    }
+    get(command, type) {
+        switch (type) {
+            case builders_1.CommandBuilderType.SlashCommand:
+                return this.slashCommands.get(command);
+            case builders_1.CommandBuilderType.MessageCommand:
+                return this.messageCommands.get(command.toLowerCase())
+                    ?? (this.client.config.commands.messageCommand.allowCommandAlias
+                        ? this.messageCommands.find(c => c.aliases.some(a => a == command?.toLowerCase()))
+                        : undefined);
+            default:
+                throw new TypeError('Unknown command type');
+        }
+    }
+    /**
+     * Register application commands
+     * @param guilds Register application commands to guilds
+     */
+    async registerApplicationCommands(...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(guilds);
+        guilds = guilds.length
+            ? guilds
+            : (0, discord_js_1.normalizeArray)([this.client.config.commands.slashCommand.guilds]);
+        if (this.client.isClientLogsEnabled())
+            this.client.logger.log(`Regestering ${this.applicationCommandsSize} application command(s) ${!guilds.length ? 'globaly' : 'to ' + guilds.length + ' guilds'}...`);
+        await this.client.applicationCommands.set([...this.slashCommands.toJSON(), ...this.additionalApplicationCommands], guilds);
+        this.client.emit('RegisterApplicationCommands');
+        return this;
+    }
+}
+exports.ClientCommandManager = ClientCommandManager;

package/dist/cjs/reciple/classes/managers/ClientModuleManager.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientModuleManager = void 0;
+const crypto_1 = require("crypto");
+const discord_js_1 = require("discord.js");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const wildcard_match_1 = __importDefault(require("wildcard-match"));
+const flags_1 = require("../../flags");
+const builders_1 = require("../../types/builders");
+const util_1 = require("../../util");
+const version_1 = require("../../version");
+const MessageCommandBuilder_1 = require("../builders/MessageCommandBuilder");
+const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
+class ClientModuleManager {
+    constructor(options) {
+        this.modules = new discord_js_1.Collection();
+        this.client = options.client;
+        options.modules?.forEach(m => {
+            if (!m.id)
+                m.id = (0, crypto_1.randomUUID)();
+            this.modules.set(m.id, this.resolveModule(m));
+        });
+    }
+    async startModulesFromFiles(options) {
+        const modules = await this.resolveModulesFromFiles(options);
+        for (const module_ of modules) {
+            try {
+                await this.startModule(module_);
+            }
+            catch (err) {
+                if (options.dontSkipError)
+                    throw err;
+                if (this.client.isClientLogsEnabled())
+                    this.client.logger.err(`Cannot start module ${ClientModuleManager.getModuleDisplayId(module_)}:`, err);
+            }
+        }
+        return modules;
+    }
+    async resolveModulesFromFiles(options) {
+        const modules = [];
+        const isVersionCheckDisabled = (options.disabeVersionCheck || this.client.config.disableVersionCheck);
+        for (const file of options.files) {
+            const moduleFileName = path_1.default.basename(file);
+            const moduleDirPath = path_1.default.dirname(file);
+            const id = (0, crypto_1.randomUUID)();
+            let script;
+            try {
+                const resolveModuleFile = await Promise.resolve().then(() => __importStar(require(file)));
+                script = resolveModuleFile?.default ?? resolveModuleFile;
+                const module_ = this.resolveModule({
+                    id,
+                    script,
+                    info: {
+                        filename: moduleFileName,
+                        path: moduleDirPath
+                    }
+                }, isVersionCheckDisabled);
+                modules.push(module_);
+                if (this.client.isClientLogsEnabled())
+                    this.client.logger.log(`Resolved ${file}`);
+            }
+            catch (err) {
+                if (options.dontSkipError)
+                    throw err;
+                if (this.client.isClientLogsEnabled())
+                    this.client.logger.err(`Cannot resolve module file ${file}:`, err);
+            }
+        }
+        return modules;
+    }
+    resolveScriptCommands(...modules) {
+        const resolvedCommands = [];
+        for (const script of (0, discord_js_1.normalizeArray)(modules)) {
+            const commands = [];
+            if (Array.isArray(script?.commands)) {
+                for (const command of script.commands) {
+                    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));
+                    }
+                }
+            }
+            const invalidBuilders = commands.some(c => !(0, util_1.validateCommandBuilder)(c));
+            if (invalidBuilders)
+                throw new Error(`Module script commands contains a command builder without name or option name`);
+            resolvedCommands.push({
+                script,
+                commands
+            });
+        }
+        return resolvedCommands;
+    }
+    async loadAll(registerApplicationCommands, ...registerApplicationCommandsGuilds) {
+        await Promise.all(this.modules.map(async (m) => {
+            if (typeof m.script?.onLoad === 'function') {
+                try {
+                    await Promise.resolve(m.script.onLoad(this.client)).catch(err => { throw err; });
+                }
+                catch (err) {
+                    this.modules.delete(m.id);
+                    if (this.client.isClientLogsEnabled())
+                        this.client.logger.error(`Error loading ${m.info.filename ?? 'unknown module'}:`, err);
+                    return;
+                }
+            }
+            this.client.commands.add(m.commands);
+            if (this.client.isClientLogsEnabled())
+                this.client.logger.log(`Loaded module: ${ClientModuleManager.getModuleDisplayId(m)}`);
+        }));
+        if (this.client.isClientLogsEnabled()) {
+            this.client.logger.info(`${this.modules.size} modules loaded.`);
+            this.client.logger.info(`${this.client.commands.messageCommands.size} message commands loaded.`);
+            this.client.logger.info(`${this.client.commands.slashCommands.size} slash commands loaded.`);
+        }
+        if (registerApplicationCommands)
+            this.client.commands.registerApplicationCommands((0, discord_js_1.normalizeArray)(registerApplicationCommandsGuilds));
+    }
+    async startModule(mod) {
+        let err;
+        const identifier = ClientModuleManager.getModuleDisplayId(mod);
+        if (this.client.isClientLogsEnabled())
+            this.client.logger.log(`Starting Module: ${identifier}`);
+        const start = await Promise.resolve(mod.script.onStart(this.client)).catch(e => err = e);
+        if (err)
+            throw err;
+        if (!start)
+            throw new Error(`Module ${identifier} returned 'false' on start`);
+        this.modules.set(mod.id, mod);
+    }
+    resolveModule(mod, disabeVersionCheck) {
+        const identifier = ClientModuleManager.getModuleDisplayId(mod);
+        if (!disabeVersionCheck && !mod?.script?.versions?.length)
+            throw new Error(`Module ${identifier} does not contain supported versions`);
+        if (typeof mod.script?.onStart !== 'function')
+            throw new Error(`Module ${identifier} does not have a valid 'onStart' method`);
+        const versions = (0, discord_js_1.normalizeArray)([mod.script.versions]);
+        const commands = this.resolveScriptCommands(mod.script)[0].commands;
+        if (!disabeVersionCheck && !versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
+            throw new Error(`Module ${identifier} does not support 'reciple@${version_1.rawVersion}'`);
+        return {
+            ...mod,
+            commands,
+        };
+    }
+    async getModuleFiles(...folders) {
+        const modules = [];
+        for (const dir of ((0, discord_js_1.normalizeArray)(folders).length ? (0, discord_js_1.normalizeArray)(folders) : (0, discord_js_1.normalizeArray)([this.client.config.modulesFolder]))) {
+            if (!(0, fs_1.existsSync)(dir))
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            if (!(0, fs_1.lstatSync)(dir).isDirectory())
+                continue;
+            modules.push(...(0, fs_1.readdirSync)(dir).map(file => path_1.default.join(flags_1.cwd, dir, file)).filter(file => file.endsWith('.js') || file.endsWith('.cjs')));
+        }
+        return modules.filter(file => !this.client.config.ignoredFiles.some(ignored => (0, wildcard_match_1.default)(ignored, path_1.default.basename(file))));
+    }
+    static getModuleDisplayId(mod) {
+        return mod.info.path && mod.info.filename ? path_1.default.join(mod.info.path, mod.info.filename) : mod.id;
+    }
+}
+exports.ClientModuleManager = ClientModuleManager;

package/dist/cjs/reciple/classes/{CommandCooldownManager.js → managers/CommandCooldownManager.js}

@@ -20,21 +20,24 @@ class CommandCooldownManager extends Array {
      * Remove cooldown from specific user, channel or guild
      * @param options Remove cooldown data options
      * @param limit Remove cooldown data limit
+     * @returns Returns the removed values
      */
     remove(options, limit = 0) {
         if (!Object.keys(options).length)
             throw new TypeError('Provide atleast one option to remove cooldown data.');
+        const removed = [];
         let i = 0;
-        for (const index in this) {
-            if (!CommandCooldownManager.checkOptions(options, this[index]))
+        for (let i = 0; i < this.length; i++) {
+            if (!CommandCooldownManager.checkOptions(options, this[i]))
                 continue;
-            if (options.expireTime && this[index].expireTime > Date.now())
+            if (options.expireTime && this[i].expireTime > Date.now())
                 continue;
             if (limit && i >= limit)
                 continue;
-            this.splice(Number(index));
-            i++;
+            removed.push(this[i]);
+            this.splice(Number(i));
         }
+        return removed;
     }
     /**
      * Check if the given user is cooled-down

package/dist/cjs/reciple/util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deprecationWarning = exports.isClass = void 0;
+exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+const builders_1 = require("./types/builders");
 /**
  * Check if an object is a class
  * @param object Object to identify
@@ -21,3 +22,11 @@ function deprecationWarning(content) {
     process.emitWarning(content, 'DeprecationWarning');
 }
 exports.deprecationWarning = deprecationWarning;
+function validateCommandBuilder(command) {
+    if (!command.name)
+        return false;
+    if (command.type === builders_1.CommandBuilderType.MessageCommand && command.options.length && command.options.some(o => !o.name))
+        return false;
+    return true;
+}
+exports.validateCommandBuilder = validateCommandBuilder;

package/dist/types/index.d.ts

@@ -1,10 +1,12 @@
-export * from './reciple/classes/CommandCooldownManager';
-export * from './reciple/classes/MessageCommandOptionManager';
-export * from './reciple/classes/RecipleClient';
-export * from './reciple/classes/RecipleConfig';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
 export * from './reciple/classes/builders/SlashCommandBuilder';
+export * from './reciple/classes/managers/ApplicationCommandManager';
+export * from './reciple/classes/managers/CommandCooldownManager';
+export * from './reciple/classes/managers/ClientCommandManager';
+export * from './reciple/classes/managers/MessageCommandOptionManager';
+export * from './reciple/classes/RecipleClient';
+export * from './reciple/classes/RecipleConfig';
 export * from './reciple/types/builders';
 export * from './reciple/types/commands';
 export * from './reciple/types/paramOptions';
@@ -12,6 +14,5 @@ export * from './reciple/flags';
 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/dist/types/reciple/classes/RecipleClient.d.ts

@@ -1,33 +1,19 @@
 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 { AnyCommandExecuteData, AnyCommandHaltData } from '../types/commands';
-import { CommandCooldownManager } from './CommandCooldownManager';
-import { RecipleClientAddModuleOptions } from '../types/paramOptions';
+import { CommandCooldownManager } from './managers/CommandCooldownManager';
+import { ApplicationCommandManager } from './managers/ApplicationCommandManager';
+import { ClientCommandManager } from './managers/ClientCommandManager';
 import { Config } from './RecipleConfig';
-import { RecipleModule } from '../modules';
 import { Logger } from 'fallout-utility';
-import { ApplicationCommandData, Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Collection, Interaction, Message, RestOrArray } from 'discord.js';
+import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
+import { ClientModuleManager } from './managers/ClientModuleManager';
 /**
  * Options for {@link RecipleClient}
  */
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
 }
-/**
- * Reciple client commands
- */
-export interface RecipleClientCommands {
-    /**
-     * Collection of loaded slash commands
-     */
-    slashCommands: Collection<string, AnySlashCommandBuilder>;
-    /**
-     * Collection of loaded message commands
-     */
-    messageCommands: Collection<string, MessageCommandBuilder>;
-}
 /**
  * Reciple client events
  */
@@ -54,37 +40,17 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
     isReady(): this is RecipleClient<true>;
 }
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
-    config: Config;
-    commands: RecipleClientCommands;
-    additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
-    cooldowns: CommandCooldownManager;
-    modules: RecipleModule[];
-    logger: Logger;
-    version: string;
+    readonly config: Config;
+    readonly commands: ClientCommandManager;
+    readonly applicationCommands: ApplicationCommandManager;
+    readonly cooldowns: CommandCooldownManager;
+    readonly modules: ClientModuleManager;
+    readonly logger: Logger;
+    readonly version: string;
     /**
      * @param options Client options
      */
     constructor(options: RecipleClientOptions);
-    /**
-     * Load and start modules from given folders
-     * @param folders folders that contains the modules you want to load
-     */
-    startModules(...folders: RestOrArray<string>): Promise<this>;
-    /**
-     * Execute {@link RecipleModule['onLoad']} from client modules and register application commands if enabled
-     */
-    loadModules(): Promise<this>;
-    /**
-     * Add module
-     * @param options Module options
-     * @deprecated This is very stupid, Just add it manually
-     */
-    addModule(options: RecipleClientAddModuleOptions): Promise<void>;
-    /**
-     * Add slash or message command to client
-     * @param command Slash/Message command builder
-     */
-    addCommand(command: AnyCommandData | AnyCommandBuilder): RecipleClient<Ready>;
     /**
      * Listed to command executions
      */
@@ -93,30 +59,19 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * Execute a slash command
      * @param interaction Slash command interaction
      */
-    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<void | SlashCommandExecuteData>;
+    slashCommandExecute(interaction: Interaction | ChatInputCommandInteraction): Promise<undefined | SlashCommandExecuteData>;
     /**
      * Execute a Message command
      * @param message Message command executor
      * @param prefix Message command prefix
      */
-    messageCommandExecute(message: Message, prefix?: string): Promise<void | MessageCommandExecuteData>;
-    /**
-     * Registers client slash commands and other application commands
-     */
-    registerClientApplicationCommands(): Promise<void>;
+    messageCommandExecute(message: Message, prefix?: string): Promise<undefined | MessageCommandExecuteData>;
     /**
      * Get a message from config
      * @param messageKey Config messages key
      * @param defaultMessage Default message when the key does not exists
      */
     getConfigMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
-    /**
-     * Get command builder by name or alias if it's a message command
-     * @param command Command name
-     * @param type Command type
-     */
-    findCommand(command: string, type: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    findCommand(command: string, type: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
     /**
      * Returns true if client logs is enabled
      */
@@ -138,8 +93,8 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @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>;
+    protected _executeCommand(command: SlashCommandBuilder, executeData: SlashCommandExecuteData): Promise<SlashCommandExecuteData | undefined>;
+    protected _executeCommand(command: MessageCommandBuilder, executeData: MessageCommandExecuteData): Promise<MessageCommandExecuteData | undefined>;
     /**
      * Error message when a command fails to execute
      * @param err Received error

package/dist/types/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -1,7 +1,7 @@
 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 { MessageCommandOptionManager } from '../managers/MessageCommandOptionManager';
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Command } from 'fallout-utility';
 /**

package/dist/types/reciple/classes/managers/ApplicationCommandManager.d.ts

@@ -0,0 +1,20 @@
+import { ApplicationCommand, ApplicationCommandData, ContextMenuCommandBuilder, GuildResolvable, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
+import { AnySlashCommandBuilder } from '../../types/builders';
+import { RecipleClient } from '../RecipleClient';
+export declare type ApplicationCommandBuilder = AnySlashCommandBuilder | ContextMenuCommandBuilder | DiscordJsSlashCommandBuilder;
+export declare class ApplicationCommandManager {
+    readonly client: RecipleClient;
+    get commands(): import("discord.js").ApplicationCommandManager<ApplicationCommand<{
+        guild: GuildResolvable;
+    }>, {
+        guild: GuildResolvable;
+    }, null> | undefined;
+    constructor(client: RecipleClient);
+    set(commands: (ApplicationCommandBuilder | ApplicationCommandData)[], guilds?: GuildResolvable[]): Promise<void>;
+    add(command: ApplicationCommandBuilder | ApplicationCommandData, guilds?: GuildResolvable[]): Promise<void>;
+    remove(command: string | ApplicationCommand, guilds?: GuildResolvable[]): Promise<void>;
+    edit(command: string | ApplicationCommand, newCommand: ApplicationCommandBuilder | ApplicationCommandData, guilds?: GuildResolvable[]): Promise<void>;
+    get(command: (ApplicationCommandData | ApplicationCommandBuilder | string), guild?: GuildResolvable): ApplicationCommand | undefined;
+    fetch(commandId: string, guild?: GuildResolvable): Promise<ApplicationCommand>;
+    protected parseCommands(commands: (ApplicationCommandData | ApplicationCommandBuilder | RESTPostAPIApplicationCommandsJSONBody)[], setPermissions?: boolean): (ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody)[];
+}

package/dist/types/reciple/classes/managers/ClientCommandManager.d.ts

@@ -0,0 +1,37 @@
+import { ApplicationCommandData, Collection, GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType, MessageCommandData, SlashCommandData } from '../../types/builders';
+import { MessageCommandBuilder } from '../builders/MessageCommandBuilder';
+import { SlashCommandBuilder } from '../builders/SlashCommandBuilder';
+import { RecipleClient } from '../RecipleClient';
+import { ApplicationCommandBuilder } from './ApplicationCommandManager';
+export interface ClientCommandManagerOptions {
+    client: RecipleClient;
+    messageCommands?: (MessageCommandBuilder | MessageCommandData)[];
+    slashCommands?: (AnySlashCommandBuilder | SlashCommandData)[];
+}
+export declare class ClientCommandManager {
+    readonly client: RecipleClient;
+    readonly slashCommands: Collection<string, AnySlashCommandBuilder>;
+    readonly messageCommands: Collection<string, MessageCommandBuilder>;
+    readonly additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
+    get applicationCommandsSize(): number;
+    constructor(options: ClientCommandManagerOptions);
+    /**
+     * Add command to command manager
+     * @param commands Any command data or builder
+     */
+    add(...commands: RestOrArray<AnyCommandBuilder | AnyCommandData>): this;
+    /**
+     * Get command builder by name or alias if it's a message command
+     * @param command Command name
+     * @param type Command type
+     */
+    get(command: string, type?: undefined): AnyCommandBuilder | undefined;
+    get(command: string, type?: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
+    get(command: string, type?: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
+    /**
+     * Register application commands
+     * @param guilds Register application commands to guilds
+     */
+    registerApplicationCommands(...guilds: RestOrArray<GuildResolvable>): Promise<this>;
+}

package/dist/types/reciple/classes/managers/ClientModuleManager.d.ts

@@ -0,0 +1,79 @@
+import { Collection, GuildResolvable, RestOrArray } from 'discord.js';
+import { AnyCommandBuilder, AnyCommandData } from '../../types/builders';
+import { ModuleManagerResolveFilesOptions } from '../../types/paramOptions';
+import { RecipleClient } from '../RecipleClient';
+/**
+ * Reciple script object
+ */
+export interface RecipleScript {
+    /**
+     * Supported reciple versions
+     */
+    versions: string | string[];
+    /**
+     * Module commands
+     */
+    commands?: (AnyCommandBuilder | AnyCommandData)[];
+    /**
+     * Action on module start
+     * @param client Bot client
+     */
+    onStart(client: RecipleClient<false>): boolean | Promise<boolean>;
+    /**
+     * Action on bot ready
+     * @param client Bot client
+     */
+    onLoad?(client: RecipleClient<true>): void | Promise<void>;
+}
+/**
+ * Reciple module object
+ */
+export interface RecipleModule {
+    /**
+     * Module Id
+     */
+    id: string;
+    /**
+     * Module script
+     */
+    script: RecipleScript;
+    /**
+     * Module local information
+     */
+    info: {
+        /**
+         * Module file name
+         */
+        filename?: string;
+        /**
+         * Module local file path
+         */
+        path?: string;
+    };
+}
+export interface ResolvedModule extends RecipleModule {
+    commands: AnyCommandBuilder[];
+}
+export interface ResolvedScriptCommands {
+    script: RecipleScript;
+    commands: AnyCommandBuilder[];
+}
+export interface ClientModuleManagerOptions {
+    client: RecipleClient;
+    modules?: (RecipleModule & {
+        id?: string;
+    })[];
+}
+export declare class ClientModuleManager {
+    readonly client: RecipleClient;
+    readonly modules: Collection<string, ResolvedModule>;
+    constructor(options: ClientModuleManagerOptions);
+    startModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
+    resolveModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
+    resolveScriptCommands(...modules: RestOrArray<RecipleScript>): ResolvedScriptCommands[];
+    loadAll(registerApplicationCommands?: boolean, ...registerApplicationCommandsGuilds: RestOrArray<GuildResolvable>): Promise<void>;
+    startModule(mod: ResolvedModule): Promise<void>;
+    resolveModule(mod: RecipleModule, disabeVersionCheck?: boolean): ResolvedModule;
+    getModuleFiles(...folders: RestOrArray<string>): Promise<string[]>;
+    static getModuleDisplayId(mod: RecipleModule): string;
+}

package/dist/types/reciple/classes/{CommandCooldownManager.d.ts → managers/CommandCooldownManager.d.ts}

@@ -1,5 +1,5 @@
 import { Guild, RestOrArray, TextBasedChannel, User } from 'discord.js';
-import { CommandBuilderType } from '../types/builders';
+import { CommandBuilderType } from '../../types/builders';
 /**
  * cooled-down user object interface
  */
@@ -43,8 +43,9 @@ export declare class CommandCooldownManager extends Array<CooledDownUser> {
      * Remove cooldown from specific user, channel or guild
      * @param options Remove cooldown data options
      * @param limit Remove cooldown data limit
+     * @returns Returns the removed values
      */
-    remove(options: Partial<CooledDownUser>, limit?: number): void;
+    remove(options: Partial<CooledDownUser>, limit?: number): CooledDownUser[];
     /**
      * Check if the given user is cooled-down
      * @param options Options to identify if user is on cooldown

package/dist/types/reciple/classes/{MessageCommandOptionManager.d.ts → managers/MessageCommandOptionManager.d.ts}

@@ -1,4 +1,4 @@
-import { MessageCommandValidatedOption } from './builders/MessageCommandBuilder';
+import { MessageCommandValidatedOption } from '../builders/MessageCommandBuilder';
 import { RestOrArray } from 'discord.js';
 /**
  * Validated message options manager

package/dist/types/reciple/types/commands.d.ts

@@ -1,7 +1,7 @@
 import { MessageCommandExecuteData, MessageCommandHaltData } from '../classes/builders/MessageCommandBuilder';
 import { SlashCommandExecuteData, SlashCommandHaltData } from '../classes/builders/SlashCommandBuilder';
-import { MessageCommandOptionManager } from '../classes/MessageCommandOptionManager';
-import { CooledDownUser } from '../classes/CommandCooldownManager';
+import { MessageCommandOptionManager } from '../classes/managers/MessageCommandOptionManager';
+import { CooledDownUser } from '../classes/managers/CommandCooldownManager';
 import { RecipleClient } from '../classes/RecipleClient';
 import { CommandBuilderType } from '../types/builders';
 /**

package/dist/types/reciple/types/paramOptions.d.ts

@@ -1,8 +1,6 @@
-import { ApplicationCommandBuilder } from '../registerApplicationCommands';
-import { ApplicationCommandData, PermissionsBitField } from 'discord.js';
 import { ConfigCommandPermissions } from '../classes/RecipleConfig';
 import { RecipleModule, RecipleScript } from '../modules';
-import { RecipleClient } from '../classes/RecipleClient';
+import { PermissionsBitField } from 'discord.js';
 import { AnyCommandBuilder } from './builders';
 export interface RecipleClientAddModuleOptions {
     /**
@@ -18,20 +16,6 @@ export interface RecipleClientAddModuleOptions {
      */
     moduleInfo?: RecipleModule["info"];
 }
-export interface RegisterApplicationCommandsOptions {
-    /**
-     * Bot client
-     */
-    client: RecipleClient;
-    /**
-     * Commands to register
-     */
-    commands: (ApplicationCommandData | ApplicationCommandBuilder)[];
-    /**
-     * Set guild to not register commands globally
-     */
-    guilds?: string | string[];
-}
 export interface UserHasCommandPermissionsOptions {
     /**
      * Command builder
@@ -49,3 +33,8 @@ export interface UserHasCommandPermissionsOptions {
         commands: ConfigCommandPermissions[];
     };
 }
+export interface ModuleManagerResolveFilesOptions {
+    files: string[];
+    disabeVersionCheck?: boolean;
+    dontSkipError?: boolean;
+}

package/dist/types/reciple/util.d.ts

@@ -1,3 +1,4 @@
+import { AnyCommandBuilder } from './types/builders';
 /**
  * Check if an object is a class
  * @param object Object to identify
@@ -8,3 +9,4 @@ export declare function isClass<T = any>(object: any): object is T;
  * @param content Warning content
  */
 export declare function deprecationWarning(content: string | Error): void;
+export declare function validateCommandBuilder(command: AnyCommandBuilder): boolean;

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "reciple",
-  "version": "5.6.0",
-  "bin": "dist/cjs/bin.js",
+  "version": "6.0.0-dev.1",
+  "bin": "./dist/cjs/bin.js",
   "license": "GPL-3.0",
-  "main": "dist/cjs/index.js",
-  "typings": "dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "typings": "./dist/types/index.d.ts",
+  "module": "./dist/mjs/index.js",
   "author": "FalloutStudios",
   "description": "Handler for Discord.js",
   "homepage": "https://reciple.js.org",
+  "exports": {
+    "require": "./dist/cjs/index.js",
+    "import": "./dist/mjs/index.js"
+  },
   "keywords": [
     "Discord",
     "Discord.js handler",
-    "Reciple",
-    "Slash command handler",
-    "Message command handler"
+    "Reciple"
   ],
   "contributors": [
     "GhexterCortes"
@@ -25,7 +28,7 @@
     "clean": "yarn exec rimraf dist",
     "build": "yarn clean && yarn exec tsc",
     "build:publish": "yarn build && yarn docs && yarn npm publish",
-    "build:publish-prerelease": "yarn build && yarn npm publish --tag pre",
+    "build:publish-dev": "yarn build && yarn npm publish --tag dev",
     "test": "yarn build && yarn workspace test start",
     "docs": "yarn exec docgen --typescript true -c ./docs/index.json -o ./docs/docs.json -i src/index.ts",
     "watch": "yarn exec tsc --watch --noEmit"
@@ -41,7 +44,6 @@
   "files": [
     "dist",
     "resource",
-    "package.json",
     "LICENSE",
     "README.md"
   ],
@@ -49,21 +51,21 @@
     "chalk": "4.1.2",
     "commander": "^9.4.1",
     "dotenv": "^16.0.3",
-    "fallout-utility": "^1.5.2",
-    "semver": "^7.3.8",
+    "fallout-utility": "^1.5.4",
+    "semver": "^7.3.7",
     "wildcard-match": "^5.1.2",
-    "yaml": "^2.1.3"
+    "yaml": "^2.1.1"
   },
   "devDependencies": {
     "@discordjs/docgen": "^0.12.1",
-    "@types/node": "^18.8.3",
+    "@types/node": "^18.11.0",
     "@types/semver": "^7.3.12",
-    "discord.js": "^14.5.0",
+    "discord.js": "^14.6.0",
     "rimraf": "^3.0.2",
     "typescript": "^4.8.4"
   },
   "peerDependencies": {
-    "discord.js": "^14.1.0"
+    "discord.js": "^14.5.0"
   },
   "workspaces": [
     "test"

package/dist/cjs/reciple/registerApplicationCommands.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerApplicationCommands = void 0;
-const discord_js_1 = require("discord.js");
-const SlashCommandBuilder_1 = require("./classes/builders/SlashCommandBuilder");
-/**
- * Register application commands
- * @param options Register application commands options
- */
-async function registerApplicationCommands(options) {
-    const client = options.client;
-    const guilds = (0, discord_js_1.normalizeArray)([options.guilds]);
-    const commands = options.commands ?? client.commands.slashCommands.toJSON().map(cmd => {
-        if (cmd?.toJSON === undefined)
-            return (cmd);
-        if (SlashCommandBuilder_1.SlashCommandBuilder.isSlashCommandBuilder(cmd) && client.config.commands.slashCommand.setRequiredPermissions) {
-            const permissions = client.config.commands.slashCommand.permissions.enabled
-                ? client.config.commands.slashCommand.permissions.commands.find(cmd_ => cmd_.command.toLowerCase() === cmd.name.toLowerCase())?.permissions
-                : undefined;
-            if (permissions) {
-                cmd.setRequiredMemberPermissions(...permissions);
-                if (client.isClientLogsEnabled())
-                    client.logger.debug(`Set required permissions for ${cmd.name}`);
-            }
-        }
-        return cmd.toJSON();
-    }) ?? [];
-    if (!client.isReady())
-        throw new Error('Client is not ready');
-    if (!guilds || !guilds?.length) {
-        client.application?.commands.set(commands).then(() => {
-            if (client.isClientLogsEnabled())
-                client.logger.warn('No guilds were specified for application commands. Registered application commands globally.');
-        });
-    }
-    else {
-        if (client.isClientLogsEnabled())
-            client.logger.warn(`Registering ${commands.length} application commands to ${guilds.length} guild(s).`);
-        for (const guild of guilds) {
-            if (!guild)
-                continue;
-            client.application?.commands.set(commands, guild).then(() => {
-                if (client.isClientLogsEnabled())
-                    client.logger.warn(`Registered ${commands.length} application command(s) for ${guild}.`);
-            });
-        }
-    }
-}
-exports.registerApplicationCommands = registerApplicationCommands;

package/dist/types/reciple/registerApplicationCommands.d.ts

@@ -1,9 +0,0 @@
-import { ContextMenuCommandBuilder, SlashCommandBuilder as DiscordJsSlashCommandBuilder } from 'discord.js';
-import { RegisterApplicationCommandsOptions } from './types/paramOptions';
-import { AnySlashCommandBuilder } from './types/builders';
-export declare type ApplicationCommandBuilder = AnySlashCommandBuilder | ContextMenuCommandBuilder | DiscordJsSlashCommandBuilder;
-/**
- * Register application commands
- * @param options Register application commands options
- */
-export declare function registerApplicationCommands(options: RegisterApplicationCommandsOptions): Promise<void>;