frontend-standards-checker/dist/src/utils/logger.js

A comprehensive frontend standards validation tool with TypeScript support

/**
 * Logger utility class for structured and leveled logging.
 *
 * Supports four log levels: ERROR, WARN, INFO, and DEBUG. The verbosity of the logger
 * can be controlled via the constructor, affecting the default log level.
 *
 * Provides methods for logging messages at different levels, optionally with additional details.
 * Allows dynamic adjustment of the log level and creation of child loggers with prefixed messages.
 *
 * @example
 * const logger = new Logger(true);
 * logger.info('Application started');
 * logger.debug('Debugging details', { foo: 'bar' });
 *
 * @implements ILogger
 */
export class Logger {
    verbose;
    levels;
    currentLevel;
    constructor(verbose = false) {
        this.verbose = verbose;
        this.levels = {
            ERROR: 0,
            WARN: 1,
            INFO: 2,
            DEBUG: 3,
        };
        this.currentLevel = verbose ? this.levels.DEBUG : this.levels.INFO;
    }
    /**
     * Log an error message
     * @param message Error message
     * @param details Additional details
     */
    error(message, details = null) {
        if (this.currentLevel >= this.levels.ERROR) {
            console.error(`❌ ${message}`);
            if (details && this.verbose) {
                console.error(details);
            }
        }
    }
    /**
     * Log a warning message
     * @param message Warning message
     * @param details Additional details
     */
    warn(message, details = null) {
        if (this.currentLevel >= this.levels.WARN) {
            console.warn(`⚠️  ${message}`);
            if (details && this.verbose) {
                console.warn(details);
            }
        }
    }
    /**
     * Log an info message
     * @param message Info message
     * @param details Additional details
     */
    info(message, details = null) {
        if (this.currentLevel >= this.levels.INFO) {
            console.log(`ℹ️  ${message}`);
            if (details && this.verbose) {
                console.log(details);
            }
        }
    }
    /**
     * Log a debug message
     * @param message Debug message
     * @param details Additional details
     */
    debug(message, details = null) {
        if (this.currentLevel >= this.levels.DEBUG) {
            console.log(`🐛 ${message}`);
            if (details) {
                console.log(details);
            }
        }
    }
    /**
     * Create a child logger with a prefix
     * @param prefix Prefix for log messages
     * @returns New logger instance with prefix
     */
    withPrefix(prefix) {
        const childLogger = new Logger(this.verbose);
        // Override methods to include prefix
        const originalError = childLogger.error.bind(childLogger);
        const originalWarn = childLogger.warn.bind(childLogger);
        const originalInfo = childLogger.info.bind(childLogger);
        const originalDebug = childLogger.debug.bind(childLogger);
        childLogger.error = (message, details) => originalError(`[${prefix}] ${message}`, details);
        childLogger.warn = (message, details) => originalWarn(`[${prefix}] ${message}`, details);
        childLogger.info = (message, details) => originalInfo(`[${prefix}] ${message}`, details);
        childLogger.debug = (message, details) => originalDebug(`[${prefix}] ${message}`, details);
        return childLogger;
    }
    /**
     * Set log level dynamically
     * @param level New log level
     */
    setLevel(level) {
        this.currentLevel = this.levels[level];
    }
    /**
     * Check if a log level is enabled
     * @param level Log level to check
     * @returns True if level is enabled
     */
    isLevelEnabled(level) {
        return this.currentLevel >= this.levels[level];
    }
}
//# sourceMappingURL=logger.js.map