meocord 1.2.1 → 1.2.2

package/dist/cjs/_shared/meocord.app-CHjdCAA_.cjs

@@ -0,0 +1,496 @@
+'use strict';
+
+var discord_js = require('discord.js');
+var theme = require('./theme-BdtbtMZX.cjs');
+require('reflect-metadata');
+var inversify = require('inversify');
+var enum_index = require('../enum/index.cjs');
+var lodashEs = require('lodash-es');
+
+const mainContainer = new inversify.Container();
+
+const COMMAND_METADATA_KEY = Symbol('commands');
+const MESSAGE_HANDLER_METADATA_KEY = Symbol('message_handlers');
+const REACTION_HANDLER_METADATA_KEY = Symbol('reaction_handlers');
+/**
+ * Decorator to register message handlers in the controller.
+ *
+ * @param keyword - An optional keyword to filter messages this handler should respond to.
+ *
+ * @example
+ * ```typescript
+ * @MessageHandler('hello')
+ * async handleHelloMessage(message: Message) {
+ *   await message.reply('Hello! How can I help you?');
+ * }
+ *
+ * @MessageHandler()
+ * async handleAnyMessage(message: Message) {
+ *   console.log(`Received a message: ${message.content}`);
+ * }
+ * ```
+ */ function MessageHandler(keyword) {
+    return function(target, propertyKey, _descriptor) {
+        const handlers = Reflect.getMetadata(MESSAGE_HANDLER_METADATA_KEY, target) || [];
+        handlers.push({
+            keyword,
+            method: propertyKey.toString()
+        });
+        Reflect.defineMetadata(MESSAGE_HANDLER_METADATA_KEY, handlers, target);
+    };
+}
+/**
+ * Decorator to register reaction handlers in the controller.
+ *
+ * @param emoji - Optional emoji name to filter reactions this handler should respond to.
+ *
+ * @example
+ * ```typescript
+ * @ReactionHandler('👍')
+ * async handleThumbsUpReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
+ *   console.log(`User ${user.username} reacted with 👍`);
+ * }
+ *
+ * @ReactionHandler()
+ * async handleAnyReaction(reaction: MessageReaction, { user }: ReactionHandlerOptions) {
+ *   console.log(`User ${user.username} reacted with ${reaction.emoji.name}`);
+ * }
+ * ```
+ */ function ReactionHandler(emoji) {
+    return function(target, propertyKey, _descriptor) {
+        const handlers = Reflect.getMetadata(REACTION_HANDLER_METADATA_KEY, target) || [];
+        handlers.push({
+            emoji,
+            method: propertyKey.toString()
+        });
+        Reflect.defineMetadata(REACTION_HANDLER_METADATA_KEY, handlers, target);
+    };
+}
+/**
+ * Retrieves reaction handlers metadata from a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns An array of reaction handler metadata objects.
+ */ function getReactionHandlers(controller) {
+    return Reflect.getMetadata(REACTION_HANDLER_METADATA_KEY, controller) || [];
+}
+/**
+ * Retrieves message handlers metadata from a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns An array of message handler method names.
+ */ function getMessageHandlers(controller) {
+    return Reflect.getMetadata(MESSAGE_HANDLER_METADATA_KEY, controller) || [];
+}
+/**
+ * Helper function to create regex and parameter mappings from a pattern string.
+ *
+ * @param pattern - The pattern string to parse.
+ * @returns An object containing the generated regex and parameter names.
+ */ function createRegexFromPattern(pattern) {
+    const params = [];
+    // Escape special characters except for {} and -
+    const escapedPattern = pattern.replace(/[/\\^$*+?.()|[\]]/g, '\\$&') // Removed hyphen `-` from this list
+    ;
+    // Replace placeholders with named capturing groups
+    const regexPattern = escapedPattern.replace(/\{(\w+)}/g, (_, param)=>{
+        if (!/^\w+$/.test(param)) {
+            throw new Error(`Invalid parameter name: ${param}. Parameter names must be alphanumeric.`);
+        }
+        params.push(param);
+        return `(?<${param}>[a-zA-Z0-9]+)`;
+    });
+    // Construct the final regex
+    const regex = new RegExp(`^${regexPattern}$`);
+    return {
+        regex,
+        params
+    };
+}
+/**
+ * Decorator to register command methods in a controller.
+ *
+ * @param commandName - The name or pattern of the command.
+ * @param builderOrType - A command builder class or a command type from `CommandType`.
+ *
+ * @example
+ * ```typescript
+ * @Command('help', CommandType.SLASH)
+ * public async handleHelp(interaction: ChatInputCommandInteraction) {
+ *   await interaction.reply('This is the help command!')
+ * }
+ *
+ * @Command('stats-{id}', CommandType.BUTTON)
+ * public async handleStats(message: ButtonInteraction, { id }) {
+ *   await message.reply(`Fetching stats for ID: ${id}`);
+ * }
+ * ```
+ */ function Command(commandName, builderOrType) {
+    return function(target, propertyKey, _descriptor) {
+        const originalMethod = _descriptor.value;
+        if (!originalMethod) {
+            throw new Error(`Missing implementation for method ${propertyKey}`);
+        }
+        // Wrap original method for interaction type validation
+        _descriptor.value = function(interaction, params) {
+            const expectedInteraction = commandType === enum_index.CommandType.BUTTON && interaction instanceof discord_js.ButtonInteraction || commandType === enum_index.CommandType.SELECT_MENU && interaction instanceof discord_js.StringSelectMenuInteraction || commandType === enum_index.CommandType.SLASH && interaction instanceof discord_js.ChatInputCommandInteraction || commandType === enum_index.CommandType.CONTEXT_MENU && interaction instanceof discord_js.ContextMenuCommandInteraction || commandType === enum_index.CommandType.MODAL_SUBMIT && interaction instanceof discord_js.ModalSubmitInteraction;
+            if (!expectedInteraction) {
+                throw new Error(`Invalid interaction type passed to @Command for method: ${propertyKey}`);
+            }
+            return originalMethod.apply(this, [
+                interaction,
+                params
+            ]);
+        };
+        // Retrieve existing metadata or initialize it
+        const commands = Reflect.getMetadata(COMMAND_METADATA_KEY, target) || {};
+        let builderInstance;
+        let commandType;
+        let regex;
+        let dynamicParams = [];
+        // Determine command type and builder
+        if (typeof builderOrType === 'function') {
+            const builderObj = new builderOrType();
+            builderInstance = builderObj.build(commandName);
+            commandType = Reflect.getMetadata('commandType', builderOrType);
+            if (!(commandType in enum_index.CommandType)) {
+                throw new Error(`Metadata for 'commandType' is missing on builder ${builderOrType.name}`);
+            }
+        } else {
+            commandType = builderOrType;
+        }
+        if (commandType !== enum_index.CommandType.SLASH && commandType !== enum_index.CommandType.CONTEXT_MENU) {
+            const { regex: generatedRegex, params } = createRegexFromPattern(commandName);
+            regex = generatedRegex;
+            dynamicParams = params;
+        }
+        // Ensure commandName supports multiple entries
+        if (!commands[commandName]) {
+            commands[commandName] = [];
+        }
+        commands[commandName].push({
+            methodName: propertyKey,
+            builder: builderInstance,
+            type: commandType,
+            regex,
+            dynamicParams
+        });
+        Reflect.defineMetadata(COMMAND_METADATA_KEY, commands, target);
+    };
+}
+/**
+ * Retrieves the command map for a given controller.
+ *
+ * @param controller - The controller class instance.
+ * @returns A record containing command metadata indexed by command names.
+ */ function getCommandMap(controller) {
+    return Reflect.getMetadata(COMMAND_METADATA_KEY, controller);
+}
+/**
+ * Decorator to mark a class as a controller that can later be registered to the App class `(app.ts)` using the `@MeoCord` decorator.
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class PingSlashController {
+ *   constructor(private pingService: PingService) {}
+ *
+ *   @Command('ping', PingCommandBuilder)
+ *   async ping(interaction: ChatInputCommandInteraction) {
+ *     const response = await this.pingService.handlePing()
+ *     await interaction.reply(response)
+ *   }
+ * }
+ * ```
+ */ function Controller() {
+    return function(target) {
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            inversify.injectable()(target);
+        }
+        const injectables = Reflect.getMetadata('design:paramtypes', target) || [];
+        injectables.map((dep)=>{
+            if (!mainContainer.isBound(dep)) {
+                if (!Reflect.hasMetadata('inversify:injectable', dep)) {
+                    inversify.injectable()(dep);
+                }
+                mainContainer.bind(dep).toSelf().inSingletonScope();
+            }
+        });
+        Reflect.defineMetadata('inversify:container', mainContainer, target);
+    };
+}
+
+const createErrorEmbed = (description)=>{
+    const embed = new discord_js.EmbedBuilder();
+    embed.setColor(theme.Theme.errorColor);
+    embed.setTitle('Oops!');
+    embed.setDescription(description);
+    return embed;
+};
+
+class MeoCordApp {
+    async start() {
+        try {
+            this.logger.log('Starting bot...');
+            this.bot.on('clientReady', async ()=>{
+                this.activityInterval = setInterval(()=>{
+                    this.bot.user?.setActivity(lodashEs.sample(this.activities));
+                }, 10000);
+                await this.registerCommands();
+            });
+            this.bot.on('interactionCreate', async (interaction)=>{
+                await this.handleInteraction(interaction);
+            });
+            this.bot.on('messageCreate', async (message)=>{
+                await this.handleMessage(message);
+            });
+            this.bot.on('messageReactionAdd', async (reaction, user)=>{
+                await this.handleReaction(reaction, {
+                    user,
+                    action: enum_index.ReactionHandlerAction.ADD
+                });
+            });
+            this.bot.on('messageReactionRemove', async (reaction, user)=>{
+                await this.handleReaction(reaction, {
+                    user,
+                    action: enum_index.ReactionHandlerAction.REMOVE
+                });
+            });
+            await this.bot.login(this.discordToken);
+            this.logger.log('Bot is online!');
+        } catch (error) {
+            this.logger.error('Error during bot startup:', error);
+        }
+    }
+    async registerCommands() {
+        const builders = [];
+        for (const controller of this.controllers){
+            const commandMap = getCommandMap(controller);
+            for(const commandName in commandMap){
+                const commandMetadataArray = commandMap[commandName];
+                if (!Array.isArray(commandMetadataArray)) continue;
+                for (const { builder, type } of commandMetadataArray){
+                    if (type in enum_index.CommandType && builder) {
+                        builders.push(builder);
+                    }
+                }
+            }
+        }
+        try {
+            if (this.bot.application) {
+                await this.bot.application.commands.set(builders);
+                this.logger.log(`Registered ${builders.length} bot commands:`, builders.map((builder)=>{
+                    const json = typeof builder.toJSON === 'function' ? builder.toJSON() : builder;
+                    const typeName = json?.type === 1 ? 'SlashCommand' : json?.type === 2 ? 'UserContextMenu' : json?.type === 3 ? 'MessageContextMenu' : builder instanceof discord_js.SlashCommandBuilder ? 'SlashCommand' : 'Command';
+                    const subCommands = Array.isArray(json?.options) && json.options.length ? json.options.map((opt)=>({
+                            name: opt.name,
+                            options: opt.options.map((opt)=>opt.name)
+                        })) : undefined;
+                    const name = json?.name || builder.name;
+                    return subCommands ? {
+                        type: typeName,
+                        name,
+                        subCommands
+                    } : {
+                        type: typeName,
+                        name
+                    };
+                }));
+            }
+        } catch (error) {
+            this.logger.error('Error during command registration:', error);
+        }
+    }
+    async handleInteraction(interaction) {
+        for (const controller of this.controllers){
+            let controllerInstance = this.controllerInstancesCache.get(controller);
+            if (!controllerInstance) {
+                controllerInstance = mainContainer.get(controller.constructor);
+                this.controllerInstancesCache.set(controller, controllerInstance);
+            }
+            const commandMap = getCommandMap(controllerInstance);
+            if (!commandMap) continue;
+            let commandMetadataArray = undefined;
+            let commandIdentifier = undefined;
+            if (interaction.isChatInputCommand() || interaction.isContextMenuCommand()) {
+                commandIdentifier = interaction.commandName;
+                commandMetadataArray = commandMap[commandIdentifier];
+            } else if (interaction.isButton() || interaction.isStringSelectMenu() || interaction.isModalSubmit()) {
+                commandIdentifier = interaction.customId;
+                const foundEntry = Object.entries(commandMap).find(([commandName, metaArray])=>{
+                    if (!Array.isArray(metaArray)) return false;
+                    return metaArray.some((meta)=>{
+                        if (!meta.regex || !commandIdentifier) return false;
+                        const match = meta.regex.exec(commandIdentifier);
+                        if (match?.groups) {
+                            interaction.dynamicParams = match.groups;
+                            return true;
+                        }
+                        return commandIdentifier === commandName;
+                    });
+                });
+                if (foundEntry) {
+                    commandMetadataArray = foundEntry[1];
+                }
+            }
+            if (commandMetadataArray && commandMetadataArray.length > 0) {
+                const commandMetadata = commandMetadataArray[0];
+                const { methodName, type } = commandMetadata;
+                try {
+                    if (type === enum_index.CommandType.SLASH && interaction.isChatInputCommand() || type === enum_index.CommandType.BUTTON && interaction.isButton() || type === enum_index.CommandType.SELECT_MENU && interaction.isStringSelectMenu() || type === enum_index.CommandType.CONTEXT_MENU && interaction.isUserContextMenuCommand() || type === enum_index.CommandType.CONTEXT_MENU && interaction.isMessageContextMenuCommand() || type === enum_index.CommandType.MODAL_SUBMIT && interaction.isModalSubmit()) {
+                        this.logger.log('[INTERACTION]', `[${enum_index.CommandType[type]}]`, `[${methodName}]`);
+                        let dynamicParams = {};
+                        if (interaction.isChatInputCommand() && interaction.options) {
+                            dynamicParams = interaction.options.data.reduce((acc, opt)=>{
+                                acc[opt.name] = opt.value;
+                                return acc;
+                            }, {});
+                        } else if (interaction.isButton() || interaction.isStringSelectMenu() || interaction.isModalSubmit()) {
+                            dynamicParams = interaction.dynamicParams || {};
+                        }
+                        await controllerInstance[methodName](interaction, dynamicParams);
+                        return;
+                    } else {
+                        this.logger.debug(type, methodName, enum_index.CommandType.BUTTON, interaction.isButton());
+                        this.logger.warn(`Interaction type mismatch for command "${commandIdentifier}". Interaction type: ${interaction.type}.`);
+                    }
+                } catch (error) {
+                    this.logger.error(`Error executing command "${commandIdentifier}":`, error);
+                    if (interaction.isRepliable()) {
+                        const embed = createErrorEmbed('An error occurred while executing the command.');
+                        await interaction.reply({
+                            embeds: [
+                                embed
+                            ],
+                            flags: discord_js.MessageFlagsBitField.Flags.Ephemeral
+                        });
+                    }
+                }
+                return;
+            }
+        }
+        // If no matching command is found
+        if (interaction.isRepliable()) {
+            const embed = createErrorEmbed('Command not found!');
+            await interaction.reply({
+                embeds: [
+                    embed
+                ],
+                flags: discord_js.MessageFlagsBitField.Flags.Ephemeral
+            });
+        }
+    }
+    async handleMessage(message) {
+        if (message.author.bot || !message.content?.trim()) return;
+        const messageContent = message.content.trim();
+        const relevantControllers = this.controllers.filter((controller)=>{
+            const messageHandlers = getMessageHandlers(controller);
+            return messageHandlers.some((handler)=>!handler.keyword || handler.keyword === messageContent);
+        });
+        for (const controller of relevantControllers){
+            let controllerInstance = this.controllerInstancesCache.get(controller.constructor);
+            if (!controllerInstance) {
+                const container = Reflect.getMetadata('inversify:container', controller.constructor);
+                controllerInstance = container.get(controller.constructor, {
+                    autobind: true
+                });
+                this.controllerInstancesCache.set(controller.constructor, controllerInstance);
+            }
+            let messageHandlers = getMessageHandlers(controller);
+            messageHandlers = messageHandlers.sort((a, b)=>{
+                if (a.keyword && !b.keyword) return -1;
+                if (!a.keyword && b.keyword) return 1;
+                return 0;
+            });
+            for (const handler of messageHandlers){
+                const { keyword, method } = handler;
+                if (!keyword || keyword === messageContent) {
+                    try {
+                        await controllerInstance[method](message);
+                    } catch (error) {
+                        this.logger.error(`Error handling message "${messageContent}" for method "${method}":`, error);
+                    }
+                }
+            }
+        }
+    }
+    async handleReaction(reaction, { user, action }) {
+        await reaction.message.fetch();
+        const relevantControllers = this.controllers.filter((controller)=>{
+            const reactionHandlers = getReactionHandlers(controller);
+            return reactionHandlers.some((handler)=>!handler.emoji || handler.emoji === reaction.emoji.name);
+        });
+        for (const controller of relevantControllers){
+            let controllerInstance = this.controllerInstancesCache.get(controller.constructor);
+            if (!controllerInstance) {
+                const container = Reflect.getMetadata('inversify:container', controller.constructor);
+                controllerInstance = container.get(controller.constructor, {
+                    autobind: true
+                });
+                this.controllerInstancesCache.set(controller.constructor, controllerInstance);
+            }
+            let reactionHandlers = getReactionHandlers(controller);
+            reactionHandlers = reactionHandlers.sort((a, b)=>{
+                if (a.emoji && !b.emoji) return -1;
+                if (!a.emoji && b.emoji) return 1;
+                return 0;
+            });
+            for (const handler of reactionHandlers){
+                const { emoji, method } = handler;
+                if (!emoji || emoji === reaction.emoji.name) {
+                    try {
+                        await controllerInstance[method](reaction, {
+                            user,
+                            action
+                        });
+                    } catch (error) {
+                        this.logger.error(`Error handling reaction "${reaction.emoji.name}" for method "${method}":`, error);
+                    }
+                }
+            }
+        }
+    }
+    async gracefulShutdown() {
+        if (this.isShuttingDown) {
+            // Second signal received while shutting down — force exit immediately
+            process.exit(1);
+        }
+        if (this.bot) {
+            try {
+                this.isShuttingDown = true;
+                this.logger.log('Shutting down bot...');
+                if (this.activityInterval) clearInterval(this.activityInterval);
+                this.bot.removeAllListeners();
+                await this.bot.destroy();
+                this.logger.log('Bot has shut down');
+                process.exit(0);
+            } catch (error) {
+                this.logger.error('Error during shutdown:', error);
+                process.exit(1);
+            }
+        }
+    }
+    constructor(controllers, discordClient, discordToken, activities){
+        this.controllers = controllers;
+        this.discordClient = discordClient;
+        this.discordToken = discordToken;
+        this.activities = activities;
+        this.logger = new theme.Logger(MeoCordApp.name);
+        this.isShuttingDown = false;
+        this.activityInterval = null;
+        this.controllerInstancesCache = new Map();
+        this.bot = this.discordClient;
+        process.on('SIGINT', ()=>this.gracefulShutdown());
+        process.on('SIGTERM', ()=>this.gracefulShutdown());
+    }
+}
+
+exports.Command = Command;
+exports.Controller = Controller;
+exports.MeoCordApp = MeoCordApp;
+exports.MessageHandler = MessageHandler;
+exports.ReactionHandler = ReactionHandler;
+exports.getCommandMap = getCommandMap;
+exports.getMessageHandlers = getMessageHandlers;
+exports.getReactionHandlers = getReactionHandlers;
+exports.mainContainer = mainContainer;

package/dist/cjs/_shared/theme-BdtbtMZX.cjs

@@ -0,0 +1,176 @@
+'use strict';
+
+var node_util = require('node:util');
+var dayjs = require('dayjs');
+var utc = require('dayjs/plugin/utc.js');
+var timezone = require('dayjs/plugin/timezone.js');
+var path = require('path');
+var fs = require('fs');
+var jiti = require('jiti');
+var chalk = require('chalk');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */ /**
+ * Helper function to fix common JSON formatting issues in tsconfig.json, such as:
+ * - Removing single-line comments.
+ * - Removing trailing commas.
+ * - Stripping newlines.
+ *
+ * @param {string} jsonString - The raw JSON string to fix.
+ * @returns {string} The corrected JSON string.
+ */ function fixJSON(jsonString) {
+    return jsonString.replace(/\/\/.*$/gm, '') // Remove single-line comments
+    .replace(/,(\s*[}\]])/g, '$1') // Remove trailing commas before } or ]
+    .replace(/,\s*$/, '') // Remove trailing commas at the end of the file
+    .replace(/^\s*[\r\n]/gm, '') // Replace empty lines only
+    ;
+}
+
+/**
+ * Loads the MeoCord configuration file (meocord.config.ts) directly at runtime
+ * using jiti, without a separate compilation step.
+ *
+ * @returns {MeoCordConfig | undefined} The loaded configuration object, or undefined if loading fails.
+ */ function loadMeoCordConfig() {
+    const configPath = path.resolve(process.cwd(), 'meocord.config.ts');
+    if (!fs.existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        // Read user's tsconfig.json to extract path aliases for jiti
+        const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+        const aliases = {};
+        if (fs.existsSync(tsConfigPath)) {
+            const tsConfig = JSON.parse(fixJSON(fs.readFileSync(tsConfigPath, 'utf-8')));
+            const paths = tsConfig?.compilerOptions?.paths;
+            if (paths) {
+                for (const [key, values] of Object.entries(paths)){
+                    // Convert TS path alias format "@src/*" -> ["./src/*"] to jiti alias format
+                    const aliasKey = key.replace('/*', '');
+                    const aliasValue = path.resolve(process.cwd(), values[0].replace('/*', ''));
+                    aliases[aliasKey] = aliasValue;
+                }
+            }
+        }
+        const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('_shared/theme-BdtbtMZX.cjs', document.baseURI).href)), {
+            interopDefault: true,
+            alias: aliases,
+            moduleCache: false
+        });
+        return jiti$1(configPath);
+    } catch (error) {
+        if (error instanceof Error) {
+            console.error(`[MeoCord] Failed to load config: ${error.message}`);
+        } else {
+            console.error(`[MeoCord] Failed to load config: Unknown error`);
+        }
+        return undefined;
+    }
+}
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+class Logger {
+    log(...args) {
+        this.logWithContext('log', args);
+    }
+    info(...args) {
+        this.logWithContext('log', args);
+    }
+    warn(...args) {
+        this.logWithContext('warn', args);
+    }
+    error(...args) {
+        this.logWithContext('error', args);
+    }
+    debug(...args) {
+        this.logWithContext('debug', args);
+    }
+    verbose(...args) {
+        this.logWithContext('log', args);
+    }
+    formatMessage(message, logType) {
+        if (typeof message === 'object' && message !== null) {
+            return node_util.inspect(message, {
+                showHidden: true,
+                depth: null,
+                colors: true,
+                compact: false,
+                showProxy: true
+            });
+        }
+        return (this.colorMap[logType] || ((msg)=>msg))(message);
+    }
+    logWithContext(logLevel, messages) {
+        if (messages.length === 0) return;
+        const config = loadMeoCordConfig();
+        const logType = logLevel.toUpperCase();
+        const applyColor = this.colorMap[logType] || ((msg)=>msg);
+        const formattedMessages = messages.map((message)=>this.formatMessage(message, logType));
+        const coloredAppName = config?.appName ? applyColor(chalk.bold(`[${config.appName}]`)) : undefined;
+        const timestamp = chalk.bold(dayjs().format('dddd, MMMM D, YYYY HH:mm:ss [UTC]Z'));
+        const coloredLogLevel = applyColor(chalk.bold(`[${logType}]`));
+        const coloredContext = this.context ? chalk.yellow.bold(`[${this.context}]`) : '';
+        const logTexts = [
+            coloredAppName,
+            timestamp,
+            coloredLogLevel,
+            coloredContext,
+            ...formattedMessages
+        ].filter((log)=>!!log);
+        console[logLevel](...logTexts);
+    }
+    constructor(context){
+        this.context = context;
+        this.colorMap = {
+            LOG: chalk.green,
+            INFO: chalk.cyan,
+            WARN: chalk.yellow,
+            ERROR: chalk.red,
+            DEBUG: chalk.magenta
+        };
+    }
+}
+
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */ class Theme {
+}
+Theme.successColor = '#28A745';
+Theme.infoColor = '#17A2B8';
+Theme.errorColor = '#DC3545';
+Theme.warningColor = '#FFC107';
+
+exports.Logger = Logger;
+exports.Theme = Theme;
+exports.loadMeoCordConfig = loadMeoCordConfig;

package/dist/cjs/common/index.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var theme = require('../_shared/theme-BdtbtMZX.cjs');
+require('node:util');
+require('dayjs');
+require('dayjs/plugin/utc.js');
+require('dayjs/plugin/timezone.js');
+require('path');
+require('fs');
+require('jiti');
+require('chalk');
+
+
+
+exports.Logger = theme.Logger;
+exports.Theme = theme.Theme;