@mks2508/better-logger 0.14.0-alpha.2 → 1.1.0

package/src/core.ts

@@ -25,10 +25,13 @@ import {
 // Universal formatting and environment detection
 import {
     createPlainOutput,
+    createOutput,
     getConsoleMethod,
     createLogEntry,
     formatTablePlain,
-    safeSerialize
+    safeSerialize,
+    detectOptimalFormat,
+    type OutputFormat
 } from './utils/formatting.js';
 
 import {
@@ -75,7 +78,8 @@ export class CoreLogger {
             enableColors: config.enableColors ?? (isBrowser ? true : false),
             enableTimestamps: config.enableTimestamps ?? true,
             enableStackTrace: config.enableStackTrace ?? false,
-            autoDetectTheme: config.autoDetectTheme ?? true
+            autoDetectTheme: config.autoDetectTheme ?? true,
+            outputFormat: config.outputFormat ?? 'auto'
         };
     }
 
@@ -148,7 +152,7 @@ export class CoreLogger {
         const message = String(args[0] || '');
         const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
         const consoleMethod = getConsoleMethod(level);
-        
+
         // Choose formatting based on environment and configuration
         if (isBrowser && this.config.enableColors && supportsCSSColors()) {
             // Browser with CSS styling
@@ -163,14 +167,14 @@ export class CoreLogger {
                 );
                 console[consoleMethod](format, ...styles, ...args.slice(1));
             } catch (error) {
-                // Fallback to plain text if CSS fails
-                const output = createPlainOutput(level, message, prefix, stackInfo);
+                // Fallback to universal formatting if CSS fails
+                const output = createOutput(level, message, prefix, stackInfo, this.config.outputFormat);
                 console[consoleMethod](output, ...args.slice(1));
             }
         } else {
-            // Node.js or browser without colors - use plain text
+            // Node.js or browser without colors - use universal formatting
             const groupIndent = '  '.repeat(this.groupDepth);
-            const output = groupIndent + createPlainOutput(level, message, prefix, stackInfo);
+            const output = groupIndent + createOutput(level, message, prefix, stackInfo, this.config.outputFormat);
             console[consoleMethod](output, ...args.slice(1));
         }
 

package/src/handlers/ExportLogHandler.ts

@@ -13,7 +13,8 @@ import type {
     BufferStats,
     ExportFormat
 } from '../types/index.js';
-import { parseTimeInput, formatDisplayTime, safeStringify, escapeHtml, generateLogId } from '../utils/index.js';
+import { parseTimeInput, formatDisplayTime } from '../utils/timestamps.js';
+import { safeStringify, escapeHtml, generateLogId } from '../utils/output.js';
 import { BUFFER_LIMITS } from '../constants.js';
 
 /**

package/src/index.ts

@@ -21,8 +21,15 @@ import type {
     ILogHandler
 } from './types/index.js';
 
-// Create singleton instance with all features enabled
-const logger = new Logger();
+// Lazy singleton - se inicializa solo cuando se necesita
+let _logger: Logger | null = null;
+
+function getLogger(): Logger {
+    if (!_logger) {
+        _logger = new Logger();
+    }
+    return _logger;
+}
 
 /**
  * Clase principal Logger con conjunto completo de características
@@ -63,7 +70,7 @@ export { Logger };
  * logger.warn('Memoria al 80%');
  * logger.error('Fallo en conexión');
  */
-export default logger;
+export default getLogger();
 
 /**
  * Métodos de logging individuales (enlazados al singleton)
@@ -78,30 +85,30 @@ export default logger;
  * 
  * @since 0.3.0
  */
-export const debug = (...args: any[]) => logger.debug(...args);
-export const info = (...args: any[]) => logger.info(...args);
-export const warn = (...args: any[]) => logger.warn(...args);
-export const error = (...args: any[]) => logger.error(...args);
-export const success = (...args: any[]) => logger.success(...args);
-export const critical = (...args: any[]) => logger.critical(...args);
-export const trace = (...args: any[]) => logger.trace(...args);
-export const table = (data: any, columns?: string[]) => logger.table(data, columns);
-export const group = (label: string, collapsed?: boolean) => logger.group(label, collapsed);
-export const groupEnd = () => logger.groupEnd();
-export const time = (label: string) => logger.time(label);
-export const timeEnd = (label: string) => logger.timeEnd(label);
-export const setGlobalPrefix = (prefix: string) => logger.setGlobalPrefix(prefix);
-export const scope = (prefix: string) => logger.scope(prefix);
-export const setVerbosity = (level: Verbosity) => logger.setVerbosity(level);
-export const addHandler = (handler: ILogHandler) => logger.addHandler(handler);
-export const setTheme = (theme: ThemeVariant) => logger.setTheme(theme);
-export const setBannerType = (bannerType: BannerType) => logger.setBannerType(bannerType);
-export const showBanner = (bannerType?: BannerType) => logger.showBanner(bannerType);
+export const debug = (...args: any[]) => getLogger().debug(...args);
+export const info = (...args: any[]) => getLogger().info(...args);
+export const warn = (...args: any[]) => getLogger().warn(...args);
+export const error = (...args: any[]) => getLogger().error(...args);
+export const success = (...args: any[]) => getLogger().success(...args);
+export const critical = (...args: any[]) => getLogger().critical(...args);
+export const trace = (...args: any[]) => getLogger().trace(...args);
+export const table = (data: any, columns?: string[]) => getLogger().table(data, columns);
+export const group = (label: string, collapsed?: boolean) => getLogger().group(label, collapsed);
+export const groupEnd = () => getLogger().groupEnd();
+export const time = (label: string) => getLogger().time(label);
+export const timeEnd = (label: string) => getLogger().timeEnd(label);
+export const setGlobalPrefix = (prefix: string) => getLogger().setGlobalPrefix(prefix);
+export const scope = (prefix: string) => getLogger().scope(prefix);
+export const setVerbosity = (level: Verbosity) => getLogger().setVerbosity(level);
+export const addHandler = (handler: ILogHandler) => getLogger().addHandler(handler);
+export const setTheme = (theme: ThemeVariant) => getLogger().setTheme(theme);
+export const setBannerType = (bannerType: BannerType) => getLogger().setBannerType(bannerType);
+export const showBanner = (bannerType?: BannerType) => getLogger().showBanner(bannerType);
 export const logWithSVG = (message: string, svgContent?: string, options?: StyleOptions) => 
-    logger.logWithSVG(message, svgContent, options);
+    getLogger().logWithSVG(message, svgContent, options);
 export const logAnimated = (message: string, duration?: number) => 
-    logger.logAnimated(message, duration);
-export const cli = (command: string) => logger.cli(command);
+    getLogger().logAnimated(message, duration);
+export const cli = (command: string) => getLogger().cli(command);
 
 // Type exports
 export type {
@@ -114,7 +121,8 @@ export type {
     LoggerConfig,
     LogMetadata,
     StackInfo,
-    TimerEntry
+    TimerEntry,
+    OutputFormat
 } from './types/index.js';
 
 // Styling utilities
@@ -139,9 +147,36 @@ export { DEFAULT_CONFIG } from './constants.js';
 // Utility exports
 export {
     parseStackTrace,
-    formatTimestamp
+    formatTimestamp,
+    detectOptimalFormat,
+    createOutput,
+    createANSIOutput,
+    createBuildOutput,
+    createCIOutput
 } from './utils/index.js';
 
+// ANSI color utilities
+export {
+    ansiStyle,
+    ansiColor,
+    ansiBackground,
+    ansiBold,
+    ansiDim,
+    ansiUnderline,
+    formatLogLevelANSI,
+    formatSuccessANSI,
+    BUILD_FORMATTERS,
+    sanitizeEmojis
+} from './utils/ansi-colors.js';
+
+// Environment detection and presets
+export {
+    BUILD_PRESETS,
+    ENVIRONMENT_DETECTION,
+    detectEnvironmentPreset,
+    getOptimalConfig
+} from './constants.js';
+
 /**
  * Utilidades de estilo para crear estilos personalizados de consola
  * 

package/src/styling/SemanticStyles.ts

@@ -5,7 +5,7 @@
 import { StyleBuilder } from './StyleBuilder.js';
 import type { AdaptiveColors } from '../types/index.js';
 import { ADAPTIVE_COLORS } from '../constants.js';
-import { getAdaptiveColor } from '../utils/index.js';
+import { getAdaptiveColor } from '../utils/output.js';
 
 /**
  * Base semantic styler with common style methods

package/src/types/core.ts

@@ -77,7 +77,7 @@ export type BannerType = 'simple' | 'ascii' | 'unicode' | 'svg' | 'animated';
 /**
  * Formatos de exportación para datos de log
  * @typedef {'json' | 'csv' | 'markdown' | 'plain' | 'html'} ExportFormat
- * 
+ *
  * @description
  * - json: Formato JSON estructurado
  * - csv: Valores separados por comas para Excel/Sheets
@@ -87,6 +87,19 @@ export type BannerType = 'simple' | 'ascii' | 'unicode' | 'svg' | 'animated';
  */
 export type ExportFormat = 'json' | 'csv' | 'markdown' | 'plain' | 'html';
 
+/**
+ * Formatos de salida para diferentes entornos
+ * @typedef {'auto' | 'plain' | 'ansi' | 'build' | 'ci'} OutputFormat
+ *
+ * @description
+ * - auto: Detección automática basada en entorno (recomendado)
+ * - plain: Texto plano sin colores (máxima compatibilidad)
+ * - ansi: Colores ANSI para terminales modernos
+ * - build: Formato optimizado para builds (Next.js, webpack, etc.)
+ * - ci: Formato optimizado para CI/CD (sin emojis, texto simple)
+ */
+export type OutputFormat = 'auto' | 'plain' | 'ansi' | 'build' | 'ci';
+
 /**
  * Interfaz de configuración para instancias del logger
  * 
@@ -116,6 +129,7 @@ export interface LoggerConfig {
     bannerType?: BannerType;
     bufferSize?: number;
     autoDetectTheme?: boolean;
+    outputFormat?: OutputFormat;
 }
 
 /**

package/src/types/index.ts

@@ -10,6 +10,7 @@ export type {
     DevToolsTheme,
     BannerType,
     ExportFormat,
+    OutputFormat,
     LoggerConfig,
     StackInfo,
     TimerEntry,

package/src/utils/ansi-colors.ts

@@ -0,0 +1,333 @@
+/**
+ * @fileoverview ANSI color utilities for terminal environments
+ * @since 1.0.0
+ */
+
+import type { LogLevel } from '../types/index.js';
+import { supportsANSIColors } from './environment.js';
+
+/**
+ * ANSI color codes for terminal styling
+ */
+export const ANSI_CODES = {
+    // Colors
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37,
+
+    // Bright colors
+    brightBlack: 90,
+    brightRed: 91,
+    brightGreen: 92,
+    brightYellow: 93,
+    brightBlue: 94,
+    brightMagenta: 95,
+    brightCyan: 96,
+    brightWhite: 97,
+
+    // Background colors
+    bgBlack: 40,
+    bgRed: 41,
+    bgGreen: 42,
+    bgYellow: 43,
+    bgBlue: 44,
+    bgMagenta: 45,
+    bgCyan: 46,
+    bgWhite: 47,
+
+    // Background bright colors
+    bgBrightBlack: 100,
+    bgBrightRed: 101,
+    bgBrightGreen: 102,
+    bgBrightYellow: 103,
+    bgBrightBlue: 104,
+    bgBrightMagenta: 105,
+    bgBrightCyan: 106,
+    bgBrightWhite: 107,
+
+    // Styles
+    reset: 0,
+    bold: 1,
+    dim: 2,
+    italic: 3,
+    underline: 4,
+    blink: 5,
+    inverse: 7,
+    hidden: 8,
+    strikethrough: 9,
+
+    // Reset specific
+    resetBold: 22,
+    resetDim: 22,
+    resetItalic: 23,
+    resetUnderline: 24,
+    resetBlink: 25,
+    resetInverse: 27,
+    resetHidden: 28,
+    resetStrikethrough: 29
+} as const;
+
+/**
+ * ANSI color presets for different log levels
+ */
+export const ANSI_LEVEL_STYLES: Record<LogLevel | 'success', {
+    color: number;
+    background?: number;
+    styles: number[];
+    emoji: string;
+}> = {
+    debug: {
+        color: ANSI_CODES.brightBlack,
+        styles: [ANSI_CODES.dim],
+        emoji: '🔍'
+    },
+    info: {
+        color: ANSI_CODES.blue,
+        styles: [ANSI_CODES.bold],
+        emoji: 'ℹ️'
+    },
+    warn: {
+        color: ANSI_CODES.yellow,
+        background: ANSI_CODES.bgYellow,
+        styles: [ANSI_CODES.bold, ANSI_CODES.black],
+        emoji: '⚠️'
+    },
+    error: {
+        color: ANSI_CODES.red,
+        background: ANSI_CODES.bgRed,
+        styles: [ANSI_CODES.bold],
+        emoji: '❌'
+    },
+    critical: {
+        color: ANSI_CODES.white,
+        background: ANSI_CODES.bgRed,
+        styles: [ANSI_CODES.bold, ANSI_CODES.blink],
+        emoji: '🚨'
+    },
+    success: {
+        color: ANSI_CODES.green,
+        background: ANSI_CODES.bgGreen,
+        styles: [ANSI_CODES.bold],
+        emoji: '✅'
+    }
+};
+
+/**
+ * Creates an ANSI escape sequence
+ */
+function ansi(code: number | number[]): string {
+    const codes = Array.isArray(code) ? code : [code];
+    return `\x1b[${codes.join(';')}m`;
+}
+
+/**
+ * Applies ANSI styling to text
+ */
+export function ansiStyle(text: string, codes: number[]): string {
+    if (!supportsANSIColors()) return text;
+    return `${ansi(codes)}${text}${ansi(ANSI_CODES.reset)}`;
+}
+
+/**
+ * Applies color to text
+ */
+export function ansiColor(text: string, color: number): string {
+    return ansiStyle(text, [color]);
+}
+
+/**
+ * Applies background color to text
+ */
+export function ansiBackground(text: string, bg: number, color?: number): string {
+    if (color) {
+        return ansiStyle(text, [color, bg]);
+    }
+    return ansiStyle(text, [bg]);
+}
+
+/**
+ * Makes text bold
+ */
+export function ansiBold(text: string): string {
+    return ansiStyle(text, [ANSI_CODES.bold]);
+}
+
+/**
+ * Makes text dim
+ */
+export function ansiDim(text: string): string {
+    return ansiStyle(text, [ANSI_CODES.dim]);
+}
+
+/**
+ * Underlines text
+ */
+export function ansiUnderline(text: string): string {
+    return ansiStyle(text, [ANSI_CODES.underline]);
+}
+
+/**
+ * Specialized formatters for different contexts
+ */
+
+/**
+ * Format timestamp for terminal
+ */
+export function formatTimestampANSI(timestamp: string): string {
+    return ansiColor(timestamp, ANSI_CODES.brightBlack);
+}
+
+/**
+ * Format log level for terminal
+ */
+export function formatLogLevelANSI(level: LogLevel, useEmojis: boolean = true): string {
+    const style = ANSI_LEVEL_STYLES[level];
+    const emoji = useEmojis ? style.emoji : '';
+    const label = level.toUpperCase().padEnd(8);
+
+    if (!supportsANSIColors()) {
+        return `${emoji} ${label}`;
+    }
+
+    let codes = [style.color, ...style.styles];
+    if (style.background) {
+        codes.push(style.background);
+    }
+
+    return ansiStyle(`${emoji} ${label}`, codes);
+}
+
+/**
+ * Format success message for terminal
+ */
+export function formatSuccessANSI(message: string, useEmojis: boolean = true): string {
+    const style = ANSI_LEVEL_STYLES.success;
+    const emoji = useEmojis ? style.emoji : '';
+
+    if (!supportsANSIColors()) {
+        return `${emoji} SUCCESS: ${message}`;
+    }
+
+    const prefix = ansiStyle(`${emoji} SUCCESS:`, [style.color, ...style.styles]);
+    return `${prefix} ${message}`;
+}
+
+/**
+ * Format prefix for terminal
+ */
+export function formatPrefixANSI(prefix: string): string {
+    if (!supportsANSIColors()) {
+        return `[${prefix}]`;
+    }
+
+    return ansiStyle(`[${prefix}]`, [ANSI_CODES.cyan, ANSI_CODES.bold]);
+}
+
+/**
+ * Format file location for terminal
+ */
+export function formatLocationANSI(location: string): string {
+    if (!supportsANSIColors()) {
+        return `(${location})`;
+    }
+
+    return ansiColor(`(${location})`, ANSI_CODES.brightBlack);
+}
+
+/**
+ * Format build-specific messages
+ */
+export const BUILD_FORMATTERS = {
+    /**
+     * Format compilation step
+     */
+    compilation: (step: string, status: 'starting' | 'completed' | 'failed' = 'starting') => {
+        const stepText = ansiBold(step);
+
+        switch (status) {
+            case 'starting':
+                return `${ansiColor('⚙️', ANSI_CODES.blue)} ${stepText}...`;
+            case 'completed':
+                return `${ansiColor('✓', ANSI_CODES.green)} ${stepText} ${ansiColor('completed', ANSI_CODES.green)}`;
+            case 'failed':
+                return `${ansiColor('✗', ANSI_CODES.red)} ${stepText} ${ansiColor('failed', ANSI_CODES.red)}`;
+            default:
+                return stepText;
+        }
+    },
+
+    /**
+     * Format warning message
+     */
+    warning: (message: string) => {
+        return `${ansiColor('⚠', ANSI_CODES.yellow)} ${ansiStyle('Warning:', [ANSI_CODES.yellow, ANSI_CODES.bold])} ${message}`;
+    },
+
+    /**
+     * Format error message
+     */
+    error: (message: string) => {
+        return `${ansiColor('✗', ANSI_CODES.red)} ${ansiStyle('Error:', [ANSI_CODES.red, ANSI_CODES.bold])} ${message}`;
+    },
+
+    /**
+     * Format success message
+     */
+    success: (message: string) => {
+        return `${ansiColor('✓', ANSI_CODES.green)} ${ansiColor(message, ANSI_CODES.green)}`;
+    },
+
+    /**
+     * Format info message
+     */
+    info: (message: string) => {
+        return `${ansiColor('ℹ', ANSI_CODES.blue)} ${message}`;
+    }
+};
+
+/**
+ * Terminal-friendly emoji alternatives for environments that don't support them
+ */
+export const EMOJI_ALTERNATIVES = {
+    '🔍': '[DEBUG]',
+    'ℹ️': '[INFO]',
+    '⚠️': '[WARN]',
+    '❌': '[ERROR]',
+    '🚨': '[CRITICAL]',
+    '✅': '[OK]',
+    '✓': '[OK]',
+    '✗': '[FAIL]',
+    '⚙️': '[BUILD]',
+    '📦': '[PKG]'
+};
+
+/**
+ * Replace emojis with text alternatives for non-emoji terminals
+ */
+export function sanitizeEmojis(text: string): string {
+    // Check if we're in a terminal that likely supports emojis
+    const isModernTerminal = process.env.TERM &&
+        (process.env.TERM.includes('xterm') ||
+         process.env.TERM.includes('screen') ||
+         process.env.TERM.includes('tmux'));
+
+    const isCI = process.env.CI || process.env.GITHUB_ACTIONS || process.env.JENKINS_URL;
+
+    // Use emojis if we have a modern terminal and not in CI
+    if (isModernTerminal && !isCI) {
+        return text;
+    }
+
+    // Replace emojis with text alternatives
+    let result = text;
+    Object.entries(EMOJI_ALTERNATIVES).forEach(([emoji, alt]) => {
+        result = result.replace(new RegExp(emoji, 'g'), alt);
+    });
+
+    return result;
+}