reciple 6.0.0-dev.1 → 6.0.0-dev.10

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

@@ -7,98 +7,101 @@ class ApplicationCommandManager {
     constructor(client) {
         this.client = client;
     }
-    get commands() { return this.client.application?.commands; }
-    async set(commands, 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);
-            if (this.client.isClientLogsEnabled())
+            await this.client.application.commands.set(commands);
+            if (!this.client.isClientLogsSilent)
                 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())
+            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}...`);
         }
     }
-    async add(command, 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);
-            if (this.client.isClientLogsEnabled())
+            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);
-            if (this.client.isClientLogsEnabled())
+            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) {
+    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);
-            if (this.client.isClientLogsEnabled())
+            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);
-            if (this.client.isClientLogsEnabled())
+            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) {
+    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);
-            if (this.client.isClientLogsEnabled())
+            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);
-            if (this.client.isClientLogsEnabled())
+            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}`);
         }
     }
@@ -106,9 +109,7 @@ class ApplicationCommandManager {
         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)));
     }
     async fetch(commandId, guild) {
         const manager = guild ? this.client.guilds.resolve(guild)?.commands : this.client.application?.commands;
@@ -119,14 +120,12 @@ class ApplicationCommandManager {
     parseCommands(commands, setPermissions = true) {
         return commands.map(cmd => {
             if (cmd?.toJSON === undefined)
-                return (cmd);
+                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.isClientLogsEnabled())
+                    if (!this.client.isClientLogsSilent)
                         this.client.logger.debug(`Set required permissions for ${cmd.name}`);
                 }
             }

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

@@ -14,31 +14,33 @@ 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; }
+    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');
         }
@@ -49,13 +51,11 @@ class ClientCommandManager {
      */
     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())
+        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.emit('recipleRegisterApplicationCommands');
         return this;
     }
 }

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

@@ -27,163 +27,141 @@ var __importDefault = (this && this.__importDefault) || function (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 util_1 = require("util");
 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");
+const RecipleModule_1 = require("../RecipleModule");
 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));
-        });
+        options.modules?.forEach(m => (m instanceof RecipleModule_1.RecipleModule ? m : new RecipleModule_1.RecipleModule({ client: this.client, script: m })));
     }
-    async startModulesFromFiles(options) {
-        const modules = await this.resolveModulesFromFiles(options);
+    async startModules(modules, ignoreErrors = true) {
         for (const module_ of modules) {
+            if (!this.client.isClientLogsSilent)
+                this.client.logger.log(`Starting module '${module_}'`);
             try {
-                await this.startModule(module_);
+                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;
+                }
+                this.modules.set(module_.id, module_);
             }
             catch (err) {
-                if (options.dontSkipError)
+                if (!ignoreErrors)
                     throw err;
-                if (this.client.isClientLogsEnabled())
-                    this.client.logger.err(`Cannot start module ${ClientModuleManager.getModuleDisplayId(module_)}:`, err);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to start module '${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;
+    async loadModules(modules, addModuleCommandsToClient = true, ignoreErrors = true) {
+        for (const module_ of this.modules.toJSON()) {
             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}`);
+                await module_.load().catch(err => {
+                    throw err;
+                });
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Loaded module '${module_}'`);
+                if (addModuleCommandsToClient) {
+                    this.client.commands.add(module_.commands);
+                }
             }
             catch (err) {
-                if (options.dontSkipError)
+                if (!ignoreErrors)
                     throw err;
-                if (this.client.isClientLogsEnabled())
-                    this.client.logger.err(`Cannot resolve module file ${file}:`, err);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to load module '${module_}': `, 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));
-                    }
-                }
+    async unLoadModules(modules, removeUnloadedModules = true, ignoreErrors = true) {
+        for (const module_ of this.modules.toJSON()) {
+            try {
+                await module_.unLoad().catch(err => {
+                    throw err;
+                });
+                if (removeUnloadedModules)
+                    this.modules.delete(module_.id);
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.log(`Unloaded module '${module_}'`);
+            }
+            catch (err) {
+                if (!ignoreErrors)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Failed to unLoad module '${module_}': `, err);
             }
-            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;
+        return modules;
     }
-    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;
+    async getModulesFromFiles(options) {
+        const modules = [];
+        for (const file of options.files) {
+            try {
+                const resolveFile = await Promise.resolve().then(() => __importStar(require(file)));
+                let script = resolveFile?.default ?? resolveFile;
+                if (script instanceof RecipleModule_1.RecipleModule) {
+                    modules.push(script);
+                    continue;
                 }
+                if (!ClientModuleManager.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.dontSkipError)
+                    throw err;
+                if (!this.client.isClientLogsSilent)
+                    this.client.logger.error(`Can't resolve module from: ${file}`, err);
             }
-            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);
+        return modules;
     }
-    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,
-        };
+    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;
     }
     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]))) {
+        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')));
+            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;
+        return modules.filter(file => !this.client.config.ignoredFiles.some(ignored => (0, wildcard_match_1.default)(ignored)(path_1.default.basename(file))));
     }
 }
 exports.ClientModuleManager = ClientModuleManager;

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

@@ -47,7 +47,13 @@ class CommandCooldownManager extends Array {
         const data = this.get(options);
         if (!data)
             return false;
-        this.remove({ ...data, channel: undefined, guild: undefined, type: undefined, command: undefined });
+        this.remove({
+            ...data,
+            channel: undefined,
+            guild: undefined,
+            type: undefined,
+            command: undefined,
+        });
         if (data.expireTime < Date.now())
             return false;
         return true;

package/dist/cjs/reciple/permissions.js

@@ -7,10 +7,9 @@ const discord_js_1 = require("discord.js");
  * @param options options
  */
 function userHasCommandPermissions(options) {
-    const command = (options.commandPermissions?.enabled
-        ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase())
-        : null)
-        ?? { permissions: options.builder.requiredMemberPermissions };
+    const command = (options.commandPermissions?.enabled ? options.commandPermissions?.commands.find(c => c.command.toLowerCase() === options.builder.name.toLowerCase()) : null) ?? {
+        permissions: options.builder.requiredMemberPermissions,
+    };
     if (!command.permissions.length)
         return true;
     return options.memberPermissions ? options.memberPermissions.has(command.permissions) : false;

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

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

package/dist/cjs/reciple/util.js

@@ -1,6 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+exports.createLogger = exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const fallout_utility_1 = require("fallout-utility");
+const flags_1 = require("./flags");
 const builders_1 = require("./types/builders");
 /**
  * Check if an object is a class
@@ -25,8 +31,36 @@ 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))
+    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
+ * @param debugmode display debug messages
+ * @param colorizeMessage add logger colours to messages
+ */
+function createLogger(stringifyJSON, debugmode = false, colorizeMessage = true) {
+    return new fallout_utility_1.Logger({
+        stringifyJSON: stringifyJSON,
+        enableDebugMode: flags_1.flags.debugmode ?? debugmode,
+        loggerName: 'Main',
+        prefixes: {
+            [fallout_utility_1.LogLevels.INFO]: (name) => `[${new Date().toLocaleTimeString(undefined, {
+                hour12: false,
+            })}][${(name ? name + '/' : '') + 'INFO'}]`,
+            [fallout_utility_1.LogLevels.WARN]: (name) => `[${chalk_1.default.yellow(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.yellow((name ? name + '/' : '') + 'WARN')}]`,
+            [fallout_utility_1.LogLevels.ERROR]: (name) => `[${chalk_1.default.red(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.red((name ? name + '/' : '') + 'ERROR')}]`,
+            [fallout_utility_1.LogLevels.DEBUG]: (name) => `[${chalk_1.default.blue(new Date().toLocaleTimeString(undefined, { hour12: false }))}][${chalk_1.default.blue((name ? name + '/' : '') + 'DEBUG')}]`,
+        },
+        colorMessages: {
+            [fallout_utility_1.LogLevels.INFO]: (message) => message,
+            [fallout_utility_1.LogLevels.WARN]: (message) => (!colorizeMessage ? message : chalk_1.default.yellow(message)),
+            [fallout_utility_1.LogLevels.ERROR]: (message) => (!colorizeMessage ? message : chalk_1.default.red(message)),
+            [fallout_utility_1.LogLevels.DEBUG]: (message) => (!colorizeMessage ? message : chalk_1.default.blue(message)),
+        },
+    });
+}
+exports.createLogger = createLogger;

package/dist/types/index.d.ts

@@ -2,17 +2,17 @@ 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/CommandCooldownManager';
 export * from './reciple/classes/managers/MessageCommandOptionManager';
 export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/RecipleConfig';
+export * from './reciple/classes/RecipleModule';
 export * from './reciple/types/builders';
 export * from './reciple/types/commands';
 export * from './reciple/types/paramOptions';
 export * from './reciple/flags';
-export * from './reciple/logger';
-export * from './reciple/modules';
 export * from './reciple/permissions';
 export * from './reciple/util';
 export * from './reciple/version';

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

@@ -1,13 +1,13 @@
 import { MessageCommandBuilder, MessageCommandExecuteData, MessageCommandHaltData } from './builders/MessageCommandBuilder';
+import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
 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 { Config } from './RecipleConfig';
 import { Logger } from 'fallout-utility';
-import { Awaitable, ChatInputCommandInteraction, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
-import { ClientModuleManager } from './managers/ClientModuleManager';
 /**
  * Options for {@link RecipleClient}
  */
@@ -47,6 +47,7 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
     readonly modules: ClientModuleManager;
     readonly logger: Logger;
     readonly version: string;
+    get isClientLogsSilent(): boolean;
     /**
      * @param options Client options
      */
@@ -72,10 +73,6 @@ export declare class RecipleClient<Ready extends boolean = boolean> extends Clie
      * @param defaultMessage Default message when the key does not exists
      */
     getConfigMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
-    /**
-     * Returns true if client logs is enabled
-     */
-    isClientLogsEnabled(): boolean;
     /**
      * Emits the {@link RecipleClientEvents["recipleReplyError"]} event
      * @param error Received Error