@mks2508/better-logger 0.0.1 → 0.0.2-alpha.2

package/src/core.ts

@@ -0,0 +1,320 @@
+/**
+ * @fileoverview Core Logger Module - Minimal logging without advanced features
+ * @version 0.0.1
+ * 
+ * This module provides the essential logging functionality without visual enhancements,
+ * SVG support, or advanced styling. Perfect for lightweight applications or server-side usage.
+ */
+
+// Core types
+import type {
+    LogLevel,
+    Verbosity,
+    LoggerConfig,
+    ILogHandler,
+    LogMetadata,
+    TimerEntry
+} from './types/index.js';
+
+// Core utilities only
+import {
+    parseStackTrace,
+    formatTimestamp
+} from './utils/index.js';
+
+// Minimal constants
+import { DEFAULT_CONFIG } from './constants.js';
+
+/**
+ * Minimal Logger class with core functionality only
+ * 
+ * @example
+ * ```typescript
+ * import { CoreLogger } from '@mks2508/better-logger/core';
+ * 
+ * const logger = new CoreLogger();
+ * logger.info('Hello world');
+ * logger.error('Something went wrong', error);
+ * ```
+ */
+export class CoreLogger {
+    private config: LoggerConfig;
+    private scopedPrefix?: string;
+    private handlers: ILogHandler[] = [];
+    private timers: Map<string, TimerEntry> = new Map();
+    private groupDepth: number = 0;
+
+    /**
+     * Creates a new CoreLogger instance
+     * @param config - Optional configuration
+     */
+    constructor(config: Partial<LoggerConfig> = {}) {
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            // Force disable advanced features for core module
+            enableColors: false,
+            enableTimestamps: config.enableTimestamps ?? true,
+            enableStackTrace: config.enableStackTrace ?? false,
+        };
+    }
+
+    // ===== CONFIGURATION METHODS =====
+
+    /**
+     * Get current configuration
+     */
+    getConfig(): LoggerConfig {
+        return { ...this.config };
+    }
+
+    /**
+     * Sets the global prefix for all log messages
+     */
+    setGlobalPrefix(prefix: string): void {
+        this.config.globalPrefix = prefix;
+    }
+
+    /**
+     * Sets the verbosity level for filtering log output
+     */
+    setVerbosity(level: Verbosity): void {
+        this.config.verbosity = level;
+    }
+
+    /**
+     * Creates a scoped logger with a specific prefix
+     */
+    createScopedLogger(prefix: string): CoreLogger {
+        const scopedLogger = new CoreLogger(this.config);
+        scopedLogger.scopedPrefix = prefix;
+        scopedLogger.handlers = [...this.handlers];
+        return scopedLogger;
+    }
+
+    /**
+     * Adds a custom log handler for extensibility
+     */
+    addHandler(handler: ILogHandler): void {
+        this.handlers.push(handler);
+    }
+
+    // ===== CORE LOGGING METHODS =====
+
+    /**
+     * Checks if a log level should be output based on current verbosity
+     */
+    private shouldLog(level: LogLevel): boolean {
+        if (this.config.verbosity === 'silent') return false;
+        const levels = { debug: 0, info: 1, warn: 2, error: 3, critical: 4 };
+        return levels[level] >= levels[this.config.verbosity];
+    }
+
+    /**
+     * Gets the effective prefix (global + scoped)
+     */
+    private getEffectivePrefix(): string | undefined {
+        const parts = [this.config.globalPrefix, this.scopedPrefix].filter(Boolean);
+        return parts.length > 0 ? parts.join(':') : undefined;
+    }
+
+    /**
+     * Core logging method with minimal formatting
+     */
+    private log(level: LogLevel, ...args: any[]): void {
+        if (!this.shouldLog(level)) return;
+
+        const prefix = this.getEffectivePrefix();
+        const timestamp = this.config.enableTimestamps ? formatTimestamp() : null;
+        const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+        
+        // Simple formatting without CSS styling
+        const parts: string[] = [];
+        
+        if (timestamp) {
+            parts.push(`[${timestamp.slice(11, 23)}]`);
+        }
+        
+        parts.push(`[${level.toUpperCase()}]`);
+        
+        if (prefix) {
+            parts.push(`[${prefix}]`);
+        }
+
+        const groupIndent = '  '.repeat(this.groupDepth);
+        const logPrefix = groupIndent + parts.join(' ');
+        
+        // Output to console with simple formatting
+        console.log(logPrefix, ...args);
+        
+        if (stackInfo && this.config.enableStackTrace) {
+            console.log(`    at ${stackInfo.file}:${stackInfo.line}:${stackInfo.column}`);
+        }
+
+        // Call custom handlers
+        const metadata: LogMetadata = {
+            timestamp: timestamp || formatTimestamp(),
+            level,
+            prefix,
+            stackInfo: stackInfo || undefined,
+        };
+
+        this.handlers.forEach(handler => {
+            try {
+                handler.handle(level, String(args[0] || ''), args, metadata);
+            } catch (error) {
+                console.error('Log handler failed:', error);
+            }
+        });
+    }
+
+    /**
+     * Logs debug information (lowest priority)
+     */
+    debug(...args: any[]): void {
+        this.log('debug', ...args);
+    }
+
+    /**
+     * Logs informational messages
+     */
+    info(...args: any[]): void {
+        this.log('info', ...args);
+    }
+
+    /**
+     * Logs warning messages
+     */
+    warn(...args: any[]): void {
+        this.log('warn', ...args);
+    }
+
+    /**
+     * Logs error messages
+     */
+    error(...args: any[]): void {
+        this.log('error', ...args);
+    }
+
+    /**
+     * Logs critical errors (highest priority)
+     */
+    critical(...args: any[]): void {
+        this.log('critical', ...args);
+    }
+
+    /**
+     * Logs trace information (detailed debugging)
+     */
+    trace(...args: any[]): void {
+        this.log('debug', ...args);
+        if (this.shouldLog('debug')) {
+            console.trace(...args);
+        }
+    }
+
+    // ===== BASIC ADVANCED FEATURES =====
+
+    /**
+     * Displays data in a table format
+     */
+    table(data: any, columns?: string[]): void {
+        if (!this.shouldLog('info')) return;
+
+        const prefix = this.getEffectivePrefix();
+        console.log(`[TABLE]${prefix ? ` [${prefix}]` : ''}:`);
+        
+        if (columns) {
+            console.table(data, columns);
+        } else {
+            console.table(data);
+        }
+    }
+
+    /**
+     * Starts a collapsible group in the console
+     */
+    group(label: string, collapsed: boolean = false): void {
+        const prefix = this.getEffectivePrefix();
+        const fullLabel = `${prefix ? `[${prefix}] ` : ''}${label}`;
+        
+        if (collapsed) {
+            console.groupCollapsed(fullLabel);
+        } else {
+            console.group(fullLabel);
+        }
+        
+        this.groupDepth++;
+    }
+
+    /**
+     * Ends the current console group
+     */
+    groupEnd(): void {
+        if (this.groupDepth > 0) {
+            console.groupEnd();
+            this.groupDepth--;
+        }
+    }
+
+    /**
+     * Starts a timer with the given label
+     */
+    time(label: string): void {
+        const timer: TimerEntry = {
+            label,
+            startTime: performance.now(),
+        };
+        this.timers.set(label, timer);
+        console.log(`[TIMER] Started: ${label}`);
+    }
+
+    /**
+     * Ends a timer and logs the elapsed time
+     */
+    timeEnd(label: string): void {
+        const timer = this.timers.get(label);
+        if (!timer) {
+            this.warn(`Timer '${label}' does not exist`);
+            return;
+        }
+
+        const elapsed = performance.now() - timer.startTime;
+        this.timers.delete(label);
+        console.log(`[TIMER] ${label}: ${elapsed.toFixed(2)}ms`);
+    }
+}
+
+// Create and export singleton instance for convenience
+const coreLogger = new CoreLogger();
+
+/**
+ * Export individual methods for convenience (with proper binding)
+ */
+export const debug = (...args: any[]) => coreLogger.debug(...args);
+export const info = (...args: any[]) => coreLogger.info(...args);
+export const warn = (...args: any[]) => coreLogger.warn(...args);
+export const error = (...args: any[]) => coreLogger.error(...args);
+export const critical = (...args: any[]) => coreLogger.critical(...args);
+export const trace = (...args: any[]) => coreLogger.trace(...args);
+export const table = (data: any, columns?: string[]) => coreLogger.table(data, columns);
+export const group = (label: string, collapsed?: boolean) => coreLogger.group(label, collapsed);
+export const groupEnd = () => coreLogger.groupEnd();
+export const time = (label: string) => coreLogger.time(label);
+export const timeEnd = (label: string) => coreLogger.timeEnd(label);
+export const setGlobalPrefix = (prefix: string) => coreLogger.setGlobalPrefix(prefix);
+export const createScopedLogger = (prefix: string) => coreLogger.createScopedLogger(prefix);
+export const setVerbosity = (level: Verbosity) => coreLogger.setVerbosity(level);
+export const addHandler = (handler: ILogHandler) => coreLogger.addHandler(handler);
+
+// Export the singleton as default
+export default coreLogger;
+
+// Re-export core types
+export type {
+    LogLevel,
+    Verbosity,
+    LoggerConfig,
+    ILogHandler,
+    LogMetadata
+} from './types/index.js';

package/src/example.ts

@@ -1,88 +1,210 @@
 /**
- * @fileoverview Example usage of the advanced Logger system
+ * @fileoverview Comprehensive examples and demonstrations of Better Logger
  */
 
-import Logger, {
+import logger, {
+    Logger,
     debug,
     info,
     warn,
     error,
     success,
+    critical,
     createScopedLogger,
     setGlobalPrefix,
     setVerbosity,
+    setTheme,
+    setBannerType,
+    showBanner,
+    logWithSVG,
+    logAnimated,
+    cli,
+    createStyle,
+    stylePresets,
     FileLogHandler,
     AnalyticsLogHandler
-} from './Logger.js';
-import { StyleBuilder } from './styling/index.js';
+} from './index.js';
 
-// Example usage demonstration
-function demonstrateLogger() {
-    // Set up global configuration
-    setGlobalPrefix('APP');
-    setVerbosity('debug');
+// Visual features demonstrations
+export function demonstrateBanners() {
+    info('🎨 Banner System Demo');
+    
+    showBanner('simple');
+    setTimeout(() => showBanner('ascii'), 1000);
+    setTimeout(() => showBanner('unicode'), 2000);
+    setTimeout(() => showBanner('svg'), 3000);
+    setTimeout(() => showBanner('animated'), 4000);
+}
 
-    // Add custom handlers
-    Logger.addHandler(new FileLogHandler('app.log'));
-    Logger.addHandler(new AnalyticsLogHandler());
+export function demonstrateThemes() {
+    info('🌈 Theme System Demo');
+    
+    const themes = ['default', 'dark', 'neon', 'cyberpunk', 'retro'];
+    themes.forEach((theme, index) => {
+        setTimeout(() => {
+            setTheme(theme as any);
+            info(`Theme switched to: ${theme}`);
+        }, index * 1500);
+    });
+}
 
-    // Create scoped loggers
-    const apiLogger = createScopedLogger('API');
-    const dbLogger = createScopedLogger('DATABASE');
+export function demonstrateSVG() {
+    const logoSVG = `<svg width="100" height="50" viewBox="0 0 100 50">
+        <rect width="100" height="50" fill="#667eea"/>
+        <text x="50" y="30" font-family="Arial" font-size="12" fill="white" text-anchor="middle">LOGO</text>
+    </svg>`;
+    
+    logWithSVG('🖼️ Custom SVG Background', logoSVG, {
+        width: 300,
+        height: 60,
+        padding: '20px 100px'
+    });
+}
+
+export function demonstrateAnimations() {
+    logAnimated('✨ Loading animation...', 3);
+    setTimeout(() => logAnimated('🚀 Animation complete!', 2), 3500);
+}
+
+export function demonstrateCLI() {
+    info('💻 CLI Commands Demo');
+    
+    const commands = [
+        '/config theme:neon',
+        '/banner ascii',
+        '/verbose debug',
+        '/prefix DEMO'
+    ];
+    
+    commands.forEach((cmd, index) => {
+        setTimeout(() => {
+            info(`Executing: ${cmd}`);
+            cli(cmd);
+        }, index * 1500);
+    });
+}
+
+export function demonstrateExports() {
+    info('📤 Export functionality would be demonstrated here');
+    info('Note: Export features require ExportLogger from /exports module');
+    
+    const sampleData = [
+        { timestamp: new Date().toISOString(), level: 'info', message: 'Sample log 1' },
+        { timestamp: new Date().toISOString(), level: 'error', message: 'Sample log 2' },
+        { timestamp: new Date().toISOString(), level: 'warn', message: 'Sample log 3' }
+    ];
+    
+    logger.table(sampleData, ['timestamp', 'level', 'message']);
+}
+
+// Core features demonstrations
+export function demonstrateBasicLogging() {
+    setGlobalPrefix('DEMO');
+    setVerbosity('debug');
 
-    // Basic logging
-    info('🚀 Application started successfully');
-    debug('Debug information', { config: { mode: 'development' } });
+    debug('🐞 Debug information', { config: { mode: 'development' } });
+    info('ℹ️ Application started successfully');
     warn('⚠️ This is a warning message');
     error('❌ An error occurred', new Error('Sample error'));
     success('✅ User authentication successful');
+    critical('🔥 Critical system failure detected');
+}
 
-    // Scoped logging
-    apiLogger.info('Fetching user data', { endpoint: '/api/users' });
-    dbLogger.debug('Database query executed', { query: 'SELECT * FROM users' });
-
-    // Advanced features
-    Logger.group('User Session Details');
-    apiLogger.table([
-        { id: 1, name: 'John Doe', email: 'john@example.com' },
-        { id: 2, name: 'Jane Smith', email: 'jane@example.com' }
-    ]);
-    Logger.groupEnd();
-
-    // Performance timing
-    Logger.time('data-processing');
-    // Simulate some processing
-    setTimeout(() => {
-        Logger.timeEnd('data-processing');
-    }, 100);
-
-    // Critical error with stack trace
-    Logger.critical('🔥 Critical system failure detected');
-
-    // Custom styled logging
-    console.log(
-        '%cCustom Styled Message',
-        new StyleBuilder()
-            .bg('linear-gradient(45deg, #ff6b6b, #feca57)')
-            .color('#ffffff')
-            .padding('10px 15px')
-            .rounded('8px')
-            .shadow('0 4px 8px rgba(0,0,0,0.2)')
-            .bold()
-            .build()
-    );
-
-    // Grouped logging with data
-    const users = [
-        { name: 'Alice', role: 'admin' },
-        { name: 'Bob', role: 'user' },
-        { name: 'Charlie', role: 'admin' }
+export function demonstrateTable() {
+    const userData = [
+        { id: 1, name: 'John Doe', email: 'john@example.com', status: 'active' },
+        { id: 2, name: 'Jane Smith', email: 'jane@example.com', status: 'inactive' },
+        { id: 3, name: 'Bob Johnson', email: 'bob@example.com', status: 'active' }
     ];
+    
+    logger.table(userData);
+    logger.table(userData, ['name', 'email']);
+}
+
+export function demonstrateGrouping() {
+    logger.group('🔍 User Analysis');
+    info('Analyzing user data...');
+    
+    logger.group('📊 Statistics', false);
+    info('Total users: 150');
+    info('Active users: 120');
+    info('New this month: 25');
+    logger.groupEnd();
+    
+    logger.group('🎯 Top Users');
+    success('Premium user: Alice Johnson');
+    success('Most active: Bob Smith'); 
+    logger.groupEnd();
+    
+    logger.groupEnd();
+}
 
-    Logger.logGrouped(users, (user) => user.role);
+export function demonstrateTiming() {
+    logger.time('api-request');
+    
+    info('🌐 Making API request...');
+    
+    setTimeout(() => {
+        logger.timeEnd('api-request');
+        success('✅ API request completed');
+    }, Math.random() * 2000 + 500);
 }
 
-// Run the demonstration
-demonstrateLogger();
+export function demonstrateScopedLogger() {
+    const apiLogger = createScopedLogger('API');
+    const dbLogger = createScopedLogger('DB');
+    const authLogger = createScopedLogger('AUTH');
+    
+    apiLogger.info('🌐 Fetching user data', { endpoint: '/api/users' });
+    dbLogger.debug('💾 Database query executed', { query: 'SELECT * FROM users LIMIT 10' });
+    authLogger.success('🔐 User authentication successful', { userId: 12345 });
+    
+    apiLogger.warn('⚠️ Rate limit approaching', { remaining: 10 });
+    dbLogger.error('❌ Connection timeout', { timeout: '5s' });
+}
+
+export function demonstrateTrace() {
+    function deepFunction() {
+        function deeperFunction() {
+            logger.trace('🔍 Deep trace call with full stack');
+        }
+        deeperFunction();
+    }
+    deepFunction();
+}
+
+export function demonstrateCustomStyles() {
+    const customStyle = createStyle()
+        .bg('linear-gradient(135deg, #ff6b6b 0%, #feca57 100%)')
+        .color('white')
+        .padding('12px 20px')
+        .rounded('10px')
+        .shadow('0 4px 15px rgba(0,0,0,0.3)')
+        .bold()
+        .build();
+    
+    console.log('%c🎨 Custom Styled Message', customStyle);
+    console.log('%c✅ Success Style', stylePresets.success);
+    console.log('%c❌ Error Style', stylePresets.error);
+    console.log('%c⚠️ Warning Style', stylePresets.warning);
+}
+
+// Comprehensive demonstration
+export function demonstrateAllFeatures() {
+    info('🌟 Starting comprehensive Better Logger demonstration...');
+    
+    setTimeout(() => demonstrateBanners(), 500);
+    setTimeout(() => demonstrateBasicLogging(), 6000);
+    setTimeout(() => demonstrateCustomStyles(), 8000);
+    setTimeout(() => demonstrateGrouping(), 10000);
+    setTimeout(() => demonstrateTiming(), 13000);
+    setTimeout(() => demonstrateScopedLogger(), 16000);
+    setTimeout(() => demonstrateThemes(), 18000);
+    
+    setTimeout(() => {
+        success('🎉 Demonstration complete! Check your console for all the styled outputs.');
+    }, 25000);
+}
 
-export { demonstrateLogger };
+// Auto-run basic demo on import
+demonstrateBasicLogging();