brw-core-logger/dist/index.js

This is frontend logger utility which is used to log messages in the frontend application.

// Define log level enumeration
var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
    LogLevel[LogLevel["INFO"] = 1] = "INFO";
    LogLevel[LogLevel["WARN"] = 2] = "WARN";
    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
    LogLevel[LogLevel["SILENT"] = 4] = "SILENT"; // Special level that suppresses all output
})(LogLevel || (LogLevel = {}));
// Logger utility class
class Logger {
    constructor(name, level) {
        this.name = name;
        this.level = level !== null && level !== void 0 ? level : Logger.globalLevel;
    }
    // Set instance log level
    setLevel(level) {
        this.level = level;
    }
    // Get instance log level
    getLevel() {
        return this.level;
    }
    // Debug log
    debug(message, data) {
        this.log(LogLevel.DEBUG, message, data);
    }
    // Info log
    info(message, data) {
        this.log(LogLevel.INFO, message, data);
    }
    // Warning log
    warn(message, data) {
        this.log(LogLevel.WARN, message, data);
    }
    // Error log
    error(message, data) {
        this.log(LogLevel.ERROR, message, data);
    }
    /**
     * Start performance timer
     * @param message Description of the operation
     * @param data Additional context data
     * @returns Function to end the timer
     */
    startTimer(message, data) {
        const timerId = `${this.name}-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
        Logger.performanceTimers.set(timerId, {
            name: this.name,
            startTime: performance.now(),
            message,
            data
        });
        // Return closure function to end timing
        return () => {
            const timer = Logger.performanceTimers.get(timerId);
            if (!timer) {
                this.warn(`Timer '${timerId}' not found`);
                return;
            }
            const duration = performance.now() - timer.startTime;
            this.log(LogLevel.INFO, `${timer.message} completed`, timer.data, duration);
            Logger.performanceTimers.delete(timerId);
        };
    }
    /**
     * Measure function execution time
     * @param fn Function to measure
     * @param message Performance description
     * @param data Additional context
     * @returns Function execution result
     */
    async measure(fn, message, data) {
        const endTimer = this.startTimer(message, data);
        try {
            const result = await fn();
            endTimer();
            return result;
        }
        catch (error) {
            endTimer();
            throw error;
        }
    }
    // Core logging method
    log(level, message, data, duration) {
        if (level < this.level)
            return;
        const entry = {
            timestamp: new Date(),
            level,
            name: this.name,
            message,
            data,
            duration
        };
        // Execute all registered handlers
        Logger.handlers.forEach(handler => {
            try {
                handler(entry);
            }
            catch (e) {
                console.error(`Logger handler error: ${e.message}`);
            }
        });
    }
    // Add global log handler
    static addHandler(handler) {
        this.handlers.push(handler);
    }
    // Remove log handler
    static removeHandler(handler) {
        const index = this.handlers.indexOf(handler);
        if (index !== -1) {
            this.handlers.splice(index, 1);
        }
    }
    // Set global log level
    static setGlobalLevel(level) {
        this.globalLevel = level;
    }
    // Default console handler
    static defaultConsoleHandler(entry) {
        const { timestamp, level, name, message, data, duration } = entry;
        const timeString = timestamp.toISOString().split('T')[1].split('.')[0];
        const levelString = LogLevel[level];
        // Create styled log prefix
        const levelStyles = {
            [LogLevel.DEBUG]: 'color: #9e9e9e;',
            [LogLevel.INFO]: 'color: #2196f3;',
            [LogLevel.WARN]: 'color: #ff9800; font-weight: bold;',
            [LogLevel.ERROR]: 'color: #f44336; font-weight: bold;',
            [LogLevel.SILENT]: ''
        };
        const nameStyle = 'color: #9c27b0;';
        const timeStyle = 'color: #4caf50;';
        const messageStyle = 'font-weight: normal;';
        let logMessage = `%c[${timeString}] %c[${levelString}] %c[${name}] %c${message}`;
        if (duration !== undefined) {
            logMessage += ` %c(${duration.toFixed(2)}ms)`;
        }
        const styles = [
            timeStyle, // Time style
            levelStyles[level], // Level style
            nameStyle, // Name style
            messageStyle, // Message style
            'color: #009688;' // Duration style
        ];
        switch (level) {
            case LogLevel.DEBUG:
                console.debug(logMessage, ...styles, data || '');
                break;
            case LogLevel.INFO:
                console.info(logMessage, ...styles, data || '');
                break;
            case LogLevel.WARN:
                console.warn(logMessage, ...styles, data || '');
                break;
            case LogLevel.ERROR:
                console.error(logMessage, ...styles, data || '');
                break;
        }
    }
}
// Static configuration
Logger.globalLevel = LogLevel.INFO;
Logger.handlers = [Logger.defaultConsoleHandler];
Logger.performanceTimers = new Map();
// Export Logger class and related types
export { Logger, LogLevel };