reciple 6.0.0-dev.2 → 6.0.0-dev.21

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

@@ -8,122 +8,163 @@ class ApplicationCommandManager {
         this.client = client;
     }
     get commands() {
-        return this.client.application?.commands;
+        return [...this.client.commands.additionalApplicationCommands, ...this.client.commands.slashCommands.toJSON()];
     }
-    async set(commands, guilds) {
+    get size() {
+        return this.commands.length;
+    }
+    /**
+     * Sets application commands globally or in guilds
+     * @param commands Application commands
+     * @param guilds set only to guilds
+     */
+    async set(commands, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(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]);
+                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);
+            await this.client.application.commands.set(commands);
             if (!this.client.isClientLogsSilent)
-                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) globally...`);
+                this.client.logger.log(`Registered ${this.client.applicationCommands.size} application command(s) globally...`);
         }
         else {
-            this.client.application.commands.set(commands, guild);
+            await this.client.application.commands.set(commands, guild);
             if (!this.client.isClientLogsSilent)
-                this.client.logger.log(`Registered ${this.client.commands.applicationCommandsSize} application command(s) to guild ${guild}...`);
+                this.client.logger.log(`Registered ${this.client.applicationCommands.size} application command(s) to guild ${guild}`);
         }
     }
-    async add(command, guilds) {
+    /**
+     * Add command globally or in guilds
+     * @param command Application command
+     * @param guilds add only in guilds
+     */
+    async add(command, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(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]);
+                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);
+            await this.client.application.commands.create(command);
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Created application command '${command.name}' globally`);
         }
         else {
-            this.client.application.commands.create(command, guild);
+            await this.client.application.commands.create(command, guild);
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Created application command '${command.name}' to guild ${guild}`);
         }
     }
-    async remove(command, guilds) {
+    /**
+     * Remove application command globally or in guilds
+     * @param command id of application commmand or ApplicationCommand class
+     * @param guilds Remove from guilds
+     */
+    async remove(command, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(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]);
+                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);
+            await this.client.application.commands.delete(command);
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
         }
         else {
-            this.client.application.commands.delete(command, guild);
+            await this.client.application.commands.delete(command, guild);
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
         }
     }
-    async edit(command, newCommand, guilds) {
+    /**
+     * Edit application command globally or in guilds
+     * @param command id of application command or ApplicationCommand class
+     * @param newCommand new application command data
+     * @param guilds Edit only from guilds
+     */
+    async edit(command, newCommand, ...guilds) {
+        guilds = (0, discord_js_1.normalizeArray)(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]);
+                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);
+            await this.client.application.commands.edit(command, newCommand);
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' globally`);
         }
         else {
-            this.client.application.commands.edit(command, newCommand, guild);
+            await this.client.application.commands.edit(command, newCommand, guild);
             if (!this.client.isClientLogsSilent)
                 this.client.logger.log(`Removed application command '${typeof command === 'string' ? command : command.name}' from guild ${guild}`);
         }
     }
+    /**
+     * Get application command from cache by application command data, builder, id, or name globally or from guid
+     * @param command application command data, builder, id, or name
+     * @param guild get command from 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));
+        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)));
     }
+    /**
+     * Fetch application command by id globally or from guild
+     * @param commandId command id
+     * @param guild fetch from guild
+     */
     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);
     }
+    /**
+     * Parse application command builders to command data
+     * @param commands Application command builders
+     * @param setPermissions set slash commands permissions
+     */
     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;
+                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.isClientLogsSilent)

package/dist/{cjs/reciple/classes/managers/ClientCommandManager.js → lib/reciple/classes/managers/CommandManager.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientCommandManager = void 0;
+exports.CommandManager = 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 {
+class CommandManager {
     constructor(options) {
         this.slashCommands = new discord_js_1.Collection();
         this.messageCommands = new discord_js_1.Collection();
@@ -14,31 +14,30 @@ class ClientCommandManager {
         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) {
+            if (command.type === builders_1.CommandType.SlashCommand) {
                 this.slashCommands.set(command.name, SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
             }
-            else if (command.type === builders_1.CommandBuilderType.MessageCommand) {
+            else if (command.type === builders_1.CommandType.MessageCommand) {
                 this.messageCommands.set(command.name, MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
             }
+            else {
+                throw new Error(`Unknown reciple command type`);
+            }
         }
         return this;
     }
     get(command, type) {
         switch (type) {
-            case builders_1.CommandBuilderType.SlashCommand:
+            case builders_1.CommandType.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));
+            case builders_1.CommandType.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');
         }
@@ -51,10 +50,10 @@ class ClientCommandManager {
         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.isClientLogsSilent)
-            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');
+            this.client.logger.log(`Regestering ${this.client.applicationCommands.size} application command(s) ${!guilds.length ? 'globaly' : 'to ' + guilds.length + ' guilds'}...`);
+        await this.client.applicationCommands.set([...this.client.applicationCommands.commands], guilds);
+        this.client.emit('recipleRegisterApplicationCommands');
         return this;
     }
 }
-exports.ClientCommandManager = ClientCommandManager;
+exports.CommandManager = CommandManager;

package/dist/lib/reciple/classes/managers/ModuleManager.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleManager = void 0;
+const discord_js_1 = require("discord.js");
+const fs_1 = require("fs");
+const util_1 = require("util");
+const wildcard_match_1 = __importDefault(require("wildcard-match"));
+const RecipleModule_1 = require("../RecipleModule");
+const util_2 = require("../../util");
+class ModuleManager {
+    constructor(options) {
+        this.modules = new discord_js_1.Collection();
+        this.client = options.client;
+        options.modules?.forEach(m => (m instanceof RecipleModule_1.RecipleModule ? m : new RecipleModule_1.RecipleModule({ client: this.client, script: m })));
+    }
+    /**
+     * Start modules
+     * @param options start modules options
+     * @returns started modules
+     */
+    async startModules(options) {
+        const startedModules = [];
+        for (const module_ of options.modules) {
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Starting module '${module_}'`);
+            try {
+                let error;
+                const start = await module_.start().catch(err => {
+                    error = err;
+                    return false;
+                });
+                if (error)
+                    throw new Error(`An error occured while loading module '${module_}': \n${(0, util_1.inspect)(error)}`);
+                if (!start) {
+                    if (!this.client.isClientLogsSilent)
+                        this.client.logger.error(`Module '${module_}' returned false onStart`);
+                    continue;
+                }
+                if (options.addToModulesCollection !== false)
+                    this.modules.set(module_.id, module_);
+                startedModules.push(module_);
+            }
+            catch (err) {
+                if (options?.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to start module '${module_}': `, err);
+            }
+        }
+        return startedModules;
+    }
+    /**
+     * Load modules
+     * @param options load modules options
+     * @returns loaded modules
+     */
+    async loadModules(options) {
+        const loadedModules = [];
+        for (const module_ of options?.modules ?? this.modules.toJSON()) {
+            try {
+                await module_.load().catch(err => {
+                    throw err;
+                });
+                if (options?.resolveCommands !== false) {
+                    module_.resolveCommands();
+                    this.client.commands.add(module_.commands);
+                }
+                loadedModules.push(module_);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Loaded module '${module_}'`);
+            }
+            catch (err) {
+                if (options?.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to load module '${module_}': `, err);
+            }
+        }
+        return loadedModules;
+    }
+    /**
+     * Unload modules
+     * @param options unload modules options
+     * @returns unloaded modules
+     */
+    async unloadModules(options) {
+        const unloadedModules = [];
+        for (const module_ of options?.modules ?? this.modules.toJSON()) {
+            try {
+                await module_.unload().catch(err => {
+                    throw err;
+                });
+                unloadedModules.push(module_);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Unloaded module '${module_}'`);
+            }
+            catch (err) {
+                if (options?.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to unLoad module '${module_}': `, err);
+            }
+        }
+        return unloadedModules;
+    }
+    /**
+     * Resolve modules from file paths
+     * @param options resolve module files options
+     * @returns resolved modules
+     */
+    async resolveModuleFiles(options) {
+        const modules = [];
+        for (const file of options.files) {
+            try {
+                const resolveFile = await import((util_2.path.isAbsolute(file) ? 'file://' : '') + file);
+                let script = resolveFile instanceof RecipleModule_1.RecipleModule || ModuleManager.validateScript(resolveFile) ? resolveFile : resolveFile?.default?.default instanceof RecipleModule_1.RecipleModule || ModuleManager.validateScript(resolveFile?.default?.default) ? resolveFile.default.default : resolveFile?.default;
+                if (script instanceof RecipleModule_1.RecipleModule) {
+                    modules.push(script);
+                    continue;
+                }
+                if (!ModuleManager.validateScript(script))
+                    throw new Error(`Invalid module script: ${file}`);
+                modules.push(new RecipleModule_1.RecipleModule({
+                    client: this.client,
+                    script,
+                    filePath: file,
+                }));
+            }
+            catch (err) {
+                if (options.ignoreErrors === false)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Can't resolve module from: ${file}`, err);
+            }
+        }
+        return modules;
+    }
+    /**
+     * Validate module script
+     * @param script module script
+     * @returns `true` if script is valid
+     */
+    static validateScript(script) {
+        const s = script;
+        if (typeof s !== 'object')
+            return false;
+        if (typeof s.versions !== 'string' && !Array.isArray(s.versions))
+            return false;
+        if (typeof s.onStart !== 'function')
+            return false;
+        if (s.onLoad && typeof s.onLoad !== 'function')
+            return false;
+        if (s.onUnload && typeof s.onUnload !== 'function')
+            return false;
+        return true;
+    }
+    /**
+     * Get module file paths from folders
+     * @param options get module paths options
+     * @returns module paths
+     */
+    async getModulePaths(options) {
+        const modules = [];
+        for (const dir of options?.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 => util_2.path.join(!dir.startsWith('/') ? this.client.cwd : '', dir, file))
+                .filter(file => (options?.filter ? options.filter(file) : file.endsWith('.js'))));
+        }
+        return modules.filter(file => !(options?.ignoredFiles ?? this.client.config.ignoredFiles).some(ignored => (0, wildcard_match_1.default)(ignored)(util_2.path.basename(file))));
+    }
+}
+exports.ModuleManager = ModuleManager;

package/dist/{cjs → lib}/reciple/flags.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cwd = exports.token = exports.flags = exports.commander = void 0;
-const version_1 = require("./version");
+const version_js_1 = require("./version.js");
 const commander_1 = require("commander");
 /**
  * Commander
@@ -9,7 +9,7 @@ const commander_1 = require("commander");
 exports.commander = new commander_1.Command()
     .name('reciple')
     .description('Reciple.js - Discord.js handler cli')
-    .version(`v${version_1.rawVersion}`, '-v, --version')
+    .version(`v${version_js_1.rawVersion}`, '-v, --version')
     .argument('[current-working-directory]', 'Change the current working directory')
     .option('-t, --token <token>', 'Replace used bot token')
     .option('-c, --config <config>', 'Change path to config file')

package/dist/lib/reciple/types/builders.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandType = void 0;
+/**
+ * Types of command builders
+ */
+var CommandType;
+(function (CommandType) {
+    CommandType[CommandType["SlashCommand"] = 1] = "SlashCommand";
+    CommandType[CommandType["MessageCommand"] = 2] = "MessageCommand";
+})(CommandType = exports.CommandType || (exports.CommandType = {}));

package/dist/{cjs → lib}/reciple/types/commands.js

@@ -6,10 +6,10 @@ exports.CommandHaltReason = void 0;
  */
 var CommandHaltReason;
 (function (CommandHaltReason) {
-    CommandHaltReason[CommandHaltReason["Error"] = 0] = "Error";
-    CommandHaltReason[CommandHaltReason["Cooldown"] = 1] = "Cooldown";
-    CommandHaltReason[CommandHaltReason["InvalidArguments"] = 2] = "InvalidArguments";
-    CommandHaltReason[CommandHaltReason["MissingArguments"] = 3] = "MissingArguments";
-    CommandHaltReason[CommandHaltReason["MissingMemberPermissions"] = 4] = "MissingMemberPermissions";
-    CommandHaltReason[CommandHaltReason["MissingBotPermissions"] = 5] = "MissingBotPermissions";
+    CommandHaltReason[CommandHaltReason["Error"] = 1] = "Error";
+    CommandHaltReason[CommandHaltReason["Cooldown"] = 2] = "Cooldown";
+    CommandHaltReason[CommandHaltReason["InvalidArguments"] = 3] = "InvalidArguments";
+    CommandHaltReason[CommandHaltReason["MissingArguments"] = 4] = "MissingArguments";
+    CommandHaltReason[CommandHaltReason["MissingMemberPermissions"] = 5] = "MissingMemberPermissions";
+    CommandHaltReason[CommandHaltReason["MissingBotPermissions"] = 6] = "MissingBotPermissions";
 })(CommandHaltReason = exports.CommandHaltReason || (exports.CommandHaltReason = {}));

package/dist/{cjs/reciple/logger.js → lib/reciple/util.js}

@@ -3,10 +3,40 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = void 0;
+exports.path = exports.createLogger = exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+const chalk_1 = __importDefault(require("chalk"));
 const fallout_utility_1 = require("fallout-utility");
+const path_1 = __importDefault(require("path"));
 const flags_1 = require("./flags");
-const chalk_1 = __importDefault(require("chalk"));
+const builders_1 = require("./types/builders");
+/**
+ * Check if an object is a class
+ * @param object Object to identify
+ */
+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;
+/**
+ * Emit process warning about deprecated method/function
+ * @param content Warning content
+ */
+function deprecationWarning(content) {
+    process.emitWarning(content, 'DeprecationWarning');
+}
+exports.deprecationWarning = deprecationWarning;
+function validateCommandBuilder(command) {
+    if (!command.name)
+        return false;
+    if (command.type === builders_1.CommandType.MessageCommand && command.options.length && command.options.some(o => !o.name))
+        return false;
+    return true;
+}
+exports.validateCommandBuilder = validateCommandBuilder;
 /**
  * Create new logger
  * @param stringifyJSON stringify json objects in console
@@ -35,3 +65,4 @@ function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true)
     });
 }
 exports.createLogger = createLogger;
+exports.path = (0, fallout_utility_1.getOperatingSystem)() === fallout_utility_1.OS.WINDOWS ? path_1.default.win32 : path_1.default.posix;

package/dist/{cjs → lib}/reciple/version.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSupportedVersion = exports.parseVersion = exports.isValidVersion = exports.rawVersion = exports.version = void 0;
 const semver_1 = __importDefault(require("semver"));
-// TODO: ESM support
 /**
  * Current reciple version
  */

package/dist/types/esm.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/types/index.d.ts

@@ -1,18 +1,19 @@
-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/ClientModuleManager';
-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';
+export * from './reciple/classes/builders/MessageCommandBuilder.js';
+export * from './reciple/classes/builders/MessageCommandOptionBuilder.js';
+export * from './reciple/classes/builders/SlashCommandBuilder.js';
+export * from './reciple/classes/managers/ApplicationCommandManager.js';
+export * from './reciple/classes/managers/CommandManager.js';
+export * from './reciple/classes/managers/ModuleManager.js';
+export * from './reciple/classes/managers/CommandCooldownManager.js';
+export * from './reciple/classes/managers/MessageCommandOptionManager.js';
+export * from './reciple/classes/RecipleClient.js';
+export * from './reciple/classes/RecipleConfig.js';
+export * from './reciple/classes/RecipleModule.js';
+export * from './reciple/types/builders.js';
+export * from './reciple/types/commands.js';
+export * from './reciple/types/builders.js';
+export * from './reciple/types/builders.js';
 export * from './reciple/flags';
-export * from './reciple/logger';
-export * from './reciple/permissions';
-export * from './reciple/util';
-export * from './reciple/version';
+export * from './reciple/permissions.js';
+export * from './reciple/util.js';
+export * from './reciple/version.js';

package/dist/types/reciple/classes/RecipleClient.d.ts

@@ -1,11 +1,11 @@
-import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
 import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
+import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
 import { SlashCommandBuilder, SlashCommandExecuteData, SlashCommandHaltData } from './builders/SlashCommandBuilder';
 import { AnyCommandExecuteData, AnyCommandHaltData } from '../types/commands';
 import { CommandCooldownManager } from './managers/CommandCooldownManager';
 import { ApplicationCommandManager } from './managers/ApplicationCommandManager';
-import { ClientCommandManager } from './managers/ClientCommandManager';
-import { ClientModuleManager } from './managers/ClientModuleManager';
+import { CommandManager } from './managers/CommandManager';
+import { ModuleManager } from './managers/ModuleManager';
 import { Config } from './RecipleConfig';
 import { Logger } from 'fallout-utility';
 /**
@@ -13,6 +13,7 @@ import { Logger } from 'fallout-utility';
  */
 export interface RecipleClientOptions extends ClientOptions {
     config?: Config;
+    cwd?: string;
 }
 /**
  * Reciple client events
@@ -41,10 +42,11 @@ export interface RecipleClient<Ready extends boolean = boolean> extends Client<R
 }
 export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     readonly config: Config;
-    readonly commands: ClientCommandManager;
+    readonly commands: CommandManager;
     readonly applicationCommands: ApplicationCommandManager;
     readonly cooldowns: CommandCooldownManager;
-    readonly modules: ClientModuleManager;
+    readonly modules: ModuleManager;
+    readonly cwd: string;
     readonly logger: Logger;
     readonly version: string;
     get isClientLogsSilent(): boolean;

package/dist/types/reciple/classes/RecipleConfig.d.ts

@@ -22,6 +22,7 @@ export interface Config {
             enabled: boolean;
             replyOnError: boolean;
             registerCommands: boolean;
+            allowRegisterEmptyCommandList: boolean;
             enableCooldown: boolean;
             setRequiredPermissions: boolean;
             acceptRepliedInteractions: boolean;
@@ -81,9 +82,9 @@ export declare class RecipleConfig {
     getConfig(): Config;
     /**
      * Parse token from config
-     * @param askIfNull Ask for token if the token is null/undefined
+     * @param askIfEmpty Ask for token if the token is undefined
      */
-    parseToken(askIfNull?: boolean): string | null;
+    parseToken(askIfEmpty?: boolean): string | null;
     /**
      * Check if the config version is supported
      */