@mks2508/better-logger 0.0.1

package/src/handlers/ExportLogHandler.ts

@@ -0,0 +1,447 @@
+/**
+ * @fileoverview Export and clipboard log handler for Advanced Logger
+ */
+
+import type { 
+    ILogHandler, 
+    LogLevel, 
+    LogMetadata, 
+    LogEntry, 
+    ExportFilters, 
+    ExportOptions, 
+    ExportResult, 
+    BufferStats,
+    ExportFormat
+} from '../types/index.js';
+import { parseTimeInput, formatDisplayTime, safeStringify, escapeHtml, generateLogId } from '../utils/index.js';
+import { BUFFER_LIMITS } from '../constants.js';
+
+/**
+ * Export log handler with circular buffer and multiple export formats
+ */
+export class ExportLogHandler implements ILogHandler {
+    private buffer: LogEntry[] = [];
+    private maxSize: number;
+    private groupDepth: number = 0;
+    private currentGroup?: string;
+
+    constructor(maxSize: number = BUFFER_LIMITS.DEFAULT_SIZE) {
+        this.maxSize = Math.min(Math.max(maxSize, BUFFER_LIMITS.MIN_SIZE), BUFFER_LIMITS.MAX_SIZE);
+    }
+
+    /**
+     * Handle incoming log and store in buffer
+     */
+    handle(level: LogLevel, message: string, args: any[], metadata: LogMetadata): void {
+        const entry: LogEntry = {
+            id: generateLogId(),
+            timestamp: metadata.timestamp,
+            level,
+            prefix: metadata.prefix,
+            message,
+            args,
+            location: metadata.stackInfo,
+            groupInfo: this.groupDepth > 0 ? {
+                depth: this.groupDepth,
+                groupName: this.currentGroup
+            } : undefined
+        };
+
+        // Add to circular buffer
+        this.buffer.push(entry);
+        if (this.buffer.length > this.maxSize) {
+            this.buffer.shift(); // Remove oldest entry
+        }
+    }
+
+    /**
+     * Set group tracking for nested logs
+     */
+    setGroupInfo(depth: number, groupName?: string): void {
+        this.groupDepth = depth;
+        this.currentGroup = groupName;
+    }
+
+    /**
+     * Get buffer statistics
+     */
+    getBufferStats(): BufferStats {
+        const levelCounts = this.buffer.reduce((acc, entry) => {
+            acc[entry.level] = (acc[entry.level] || 0) + 1;
+            return acc;
+        }, {} as Record<LogLevel, number>);
+
+        return {
+            size: this.buffer.length,
+            maxSize: this.maxSize,
+            usage: (this.buffer.length / this.maxSize) * 100,
+            oldestLog: this.buffer.length > 0 ? new Date(this.buffer[0].timestamp) : undefined,
+            newestLog: this.buffer.length > 0 ? new Date(this.buffer[this.buffer.length - 1].timestamp) : undefined,
+            levelCounts: {
+                ...{
+                    debug: 0,
+                    info: 0,
+                    warn: 0,
+                    error: 0,
+                    critical: 0
+                },
+                ...levelCounts
+            }
+        };
+    }
+
+    /**
+     * Clear the buffer
+     */
+    clearBuffer(): void {
+        this.buffer = [];
+    }
+
+    /**
+     * Set buffer size (with limits)
+     */
+    setBufferSize(size: number): void {
+        this.maxSize = Math.min(Math.max(size, BUFFER_LIMITS.MIN_SIZE), BUFFER_LIMITS.MAX_SIZE);
+        
+        // Trim buffer if new size is smaller
+        if (this.buffer.length > this.maxSize) {
+            this.buffer = this.buffer.slice(-this.maxSize);
+        }
+    }
+
+    /**
+     * Filter logs based on criteria
+     */
+    private filterLogs(filters: ExportFilters = {}): LogEntry[] {
+        let filtered = [...this.buffer];
+
+        // Filter by levels
+        if (filters.levels?.length) {
+            filtered = filtered.filter(entry => filters.levels!.includes(entry.level));
+        }
+
+        // Filter by prefixes
+        if (filters.prefixes?.length) {
+            filtered = filtered.filter(entry => 
+                entry.prefix && filters.prefixes!.includes(entry.prefix)
+            );
+        }
+
+        // Exclude prefixes
+        if (filters.excludePrefixes?.length) {
+            filtered = filtered.filter(entry => 
+                !entry.prefix || !filters.excludePrefixes!.includes(entry.prefix)
+            );
+        }
+
+        // Filter by time range
+        if (filters.since) {
+            const sinceDate = parseTimeInput(filters.since);
+            filtered = filtered.filter(entry => new Date(entry.timestamp) >= sinceDate);
+        }
+
+        if (filters.until) {
+            const untilDate = parseTimeInput(filters.until);
+            filtered = filtered.filter(entry => new Date(entry.timestamp) <= untilDate);
+        }
+
+        // Filter by stack trace presence
+        if (filters.withStackTrace) {
+            filtered = filtered.filter(entry => entry.location);
+        }
+
+        // Filter errors only
+        if (filters.errorsOnly) {
+            filtered = filtered.filter(entry => entry.level === 'error' || entry.level === 'critical');
+        }
+
+        // Search in messages
+        if (filters.search) {
+            const searchTerm = filters.search.toLowerCase();
+            filtered = filtered.filter(entry => 
+                entry.message.toLowerCase().includes(searchTerm) ||
+                entry.args.some(arg => 
+                    String(arg).toLowerCase().includes(searchTerm)
+                )
+            );
+        }
+
+        // Limit results
+        if (filters.last) {
+            filtered = filtered.slice(-filters.last);
+        }
+
+        if (filters.first) {
+            filtered = filtered.slice(0, filters.first);
+        }
+
+        return filtered;
+    }
+
+    /**
+     * Export logs in JSON format
+     */
+    private exportJSON(logs: LogEntry[], options: ExportOptions): string {
+        const data = logs.map(entry => ({
+            timestamp: entry.timestamp,
+            level: entry.level,
+            prefix: entry.prefix,
+            message: entry.message,
+            ...(options.minimal ? {} : {
+                args: entry.args.slice(1),
+                location: entry.location,
+                groupInfo: entry.groupInfo
+            })
+        }));
+
+        return options.compact 
+            ? JSON.stringify(data)
+            : JSON.stringify(data, null, 2);
+    }
+
+    /**
+     * Export logs in CSV format
+     */
+    private exportCSV(logs: LogEntry[], options: ExportOptions): string {
+        const headers = options.minimal 
+            ? ['Timestamp', 'Level', 'Prefix', 'Message']
+            : ['Timestamp', 'Level', 'Prefix', 'Message', 'File', 'Line', 'Args'];
+
+        const rows = logs.map(entry => {
+            const baseRow = [
+                formatDisplayTime(new Date(entry.timestamp), 'full'),
+                entry.level.toUpperCase(),
+                entry.prefix || '',
+                `"${entry.message.replace(/"/g, '""')}"`
+            ];
+
+            if (!options.minimal) {
+                baseRow.push(
+                    entry.location?.file || '',
+                    entry.location?.line?.toString() || '',
+                    `"${safeStringify(entry.args.slice(1)).replace(/"/g, '""')}"`
+                );
+            }
+
+            return baseRow;
+        });
+
+        return [headers.join(','), ...rows.map(row => row.join(','))].join('\n');
+    }
+
+    /**
+     * Export logs in Markdown format
+     */
+    private exportMarkdown(logs: LogEntry[], options: ExportOptions): string {
+        const now = new Date();
+        let content = `# Log Export - ${formatDisplayTime(now, 'full')}\n\n`;
+
+        // Add summary if not minimal
+        if (!options.minimal) {
+            const summary = this.getBufferStats();
+            content += `## Summary\n`;
+            content += `- **Total logs**: ${logs.length}\n`;
+            content += `- **Errors**: ${summary.levelCounts.error + summary.levelCounts.critical}\n`;
+            content += `- **Warnings**: ${summary.levelCounts.warn}\n\n`;
+        }
+
+        // Group by level if specified
+        if (options.groupBy === 'level') {
+            const grouped = logs.reduce((acc, entry) => {
+                if (!acc[entry.level]) acc[entry.level] = [];
+                acc[entry.level].push(entry);
+                return acc;
+            }, {} as Record<string, LogEntry[]>);
+
+            Object.entries(grouped).forEach(([level, entries]) => {
+                const emoji = this.getLevelEmoji(level as LogLevel);
+                content += `## ${emoji} ${level.toUpperCase()} (${entries.length})\n\n`;
+                
+                entries.forEach(entry => {
+                    const time = formatDisplayTime(new Date(entry.timestamp), 'time-only');
+                    const location = entry.location ? ` (${entry.location.file}:${entry.location.line})` : '';
+                    const prefix = entry.prefix ? ` **${entry.prefix}**:` : '';
+                    content += `- \`${time}\`${prefix} ${entry.message}${location}\n`;
+                });
+                content += '\n';
+            });
+        } else {
+            content += '## Logs\n\n';
+            logs.forEach(entry => {
+                const time = formatDisplayTime(new Date(entry.timestamp), 'time-only');
+                const emoji = this.getLevelEmoji(entry.level);
+                const location = entry.location ? ` (${entry.location.file}:${entry.location.line})` : '';
+                const prefix = entry.prefix ? ` **${entry.prefix}**:` : '';
+                content += `- \`${time}\` ${emoji}${prefix} ${entry.message}${location}\n`;
+            });
+        }
+
+        return content;
+    }
+
+    /**
+     * Export logs in plain text format
+     */
+    private exportPlain(logs: LogEntry[], options: ExportOptions): string {
+        return logs.map(entry => {
+            const time = formatDisplayTime(new Date(entry.timestamp), options.minimal ? 'time-only' : 'short');
+            const level = entry.level.toUpperCase().padEnd(8);
+            const prefix = entry.prefix ? `[${entry.prefix}] ` : '';
+            const location = (!options.minimal && entry.location) ? ` (${entry.location.file}:${entry.location.line})` : '';
+            
+            return `${time} ${level} ${prefix}${entry.message}${location}`;
+        }).join('\n');
+    }
+
+    /**
+     * Export logs in HTML format
+     */
+    private exportHTML(logs: LogEntry[], _options: ExportOptions): string {
+        const title = `Log Export - ${formatDisplayTime(new Date(), 'full')}`;
+        
+        let html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; line-height: 1.6; }
+        .header { border-bottom: 2px solid #ddd; padding-bottom: 20px; margin-bottom: 20px; }
+        .log-entry { margin: 5px 0; padding: 8px; border-radius: 4px; font-family: 'Monaco', 'Consolas', monospace; }
+        .timestamp { color: #666; font-size: 0.9em; }
+        .level { font-weight: bold; padding: 2px 6px; border-radius: 3px; margin: 0 8px; }
+        .prefix { background: #2d3748; color: #e2e8f0; padding: 2px 6px; border-radius: 3px; margin: 0 8px; }
+        .location { color: #718096; font-size: 0.9em; }
+        .debug { background: #f0f4ff; }
+        .info { background: #f0f9ff; }
+        .warn { background: #fffbeb; }
+        .error { background: #fef2f2; }
+        .critical { background: #fef2f2; border-left: 4px solid #dc2626; }
+        .level.debug { background: #667eea; color: white; }
+        .level.info { background: #74b9ff; color: white; }
+        .level.warn { background: #fdcb6e; color: #2d3436; }
+        .level.error { background: #e84393; color: white; }
+        .level.critical { background: #ff3838; color: white; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>${title}</h1>
+        <p>Generated by Advanced Logger v2.0.0</p>
+    </div>
+    <div class="logs">`;
+
+        logs.forEach(entry => {
+            const time = formatDisplayTime(new Date(entry.timestamp), 'full');
+            const location = entry.location ? ` <span class="location">(${escapeHtml(entry.location.file)}:${entry.location.line})</span>` : '';
+            const prefix = entry.prefix ? ` <span class="prefix">${escapeHtml(entry.prefix)}</span>` : '';
+            
+            html += `
+        <div class="log-entry ${entry.level}">
+            <span class="timestamp">${time}</span>
+            <span class="level ${entry.level}">${entry.level.toUpperCase()}</span>
+            ${prefix}
+            <span class="message">${escapeHtml(entry.message)}</span>
+            ${location}
+        </div>`;
+        });
+
+        html += `
+    </div>
+</body>
+</html>`;
+
+        return html;
+    }
+
+    /**
+     * Get emoji for log level
+     */
+    private getLevelEmoji(level: LogLevel): string {
+        const emojis = {
+            debug: '🐞',
+            info: 'ℹ️',
+            warn: '⚠️',
+            error: '❌',
+            critical: '🔥'
+        };
+        return emojis[level] || '';
+    }
+
+    /**
+     * Main export function
+     */
+    export(format: ExportFormat, filters: ExportFilters = {}, options: ExportOptions = {}): ExportResult {
+        const filteredLogs = this.filterLogs(filters);
+        
+        let data: string;
+        switch (format) {
+            case 'json':
+                data = this.exportJSON(filteredLogs, options);
+                break;
+            case 'csv':
+                data = this.exportCSV(filteredLogs, options);
+                break;
+            case 'markdown':
+                data = this.exportMarkdown(filteredLogs, options);
+                break;
+            case 'plain':
+                data = this.exportPlain(filteredLogs, options);
+                break;
+            case 'html':
+                data = this.exportHTML(filteredLogs, options);
+                break;
+            default:
+                throw new Error(`Unsupported export format: ${format}`);
+        }
+
+        return {
+            format,
+            data,
+            metadata: {
+                totalLogs: this.buffer.length,
+                filteredLogs: filteredLogs.length,
+                exportedAt: new Date().toISOString(),
+                filters,
+                options
+            }
+        };
+    }
+
+    /**
+     * Copy to clipboard with fallback
+     */
+    async copyToClipboard(format: ExportFormat, filters: ExportFilters = {}, options: ExportOptions = {}): Promise<boolean> {
+        const result = this.export(format, filters, options);
+        
+        try {
+            if (navigator.clipboard && window.isSecureContext) {
+                await navigator.clipboard.writeText(result.data);
+                return true;
+            } else {
+                // Fallback for non-secure contexts
+                const textArea = document.createElement('textarea');
+                textArea.value = result.data;
+                textArea.style.position = 'fixed';
+                textArea.style.opacity = '0';
+                document.body.appendChild(textArea);
+                textArea.focus();
+                textArea.select();
+                const success = document.execCommand('copy');
+                document.body.removeChild(textArea);
+                return success;
+            }
+        } catch (error) {
+            console.error('Failed to copy to clipboard:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Get all logs (for debugging)
+     */
+    getAllLogs(): LogEntry[] {
+        return [...this.buffer];
+    }
+}

package/src/handlers/FileLogHandler.ts

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview File-based log handler for Advanced Logger
+ */
+
+import type { ILogHandler, LogLevel, LogMetadata } from '../types/index.js';
+
+/**
+ * File-based log handler for persistent logging
+ */
+export class FileLogHandler implements ILogHandler {
+    private filename: string;
+
+    constructor(filename: string = 'app.log') {
+        this.filename = filename;
+    }
+
+    handle(level: LogLevel, message: string, args: any[], metadata: LogMetadata): void {
+        const logEntry = {
+            filename: this.filename,
+            timestamp: metadata.timestamp,
+            level: level.toUpperCase(),
+            prefix: metadata.prefix,
+            message,
+            args: args.slice(1),
+            location: metadata.stackInfo,
+        };
+
+        console.debug('File log entry:', logEntry);
+    }
+}

package/src/handlers/RemoteLogHandler.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Remote log handler for Advanced Logger
+ */
+
+import type { ILogHandler, LogLevel, LogMetadata } from '../types/index.js';
+
+/**
+ * Remote log handler for sending logs to external services
+ */
+export class RemoteLogHandler implements ILogHandler {
+    private endpoint: string;
+    private apiKey?: string;
+
+    constructor(endpoint: string, apiKey?: string) {
+        this.endpoint = endpoint;
+        this.apiKey = apiKey;
+    }
+
+    async handle(level: LogLevel, message: string, args: any[], metadata: LogMetadata): Promise<void> {
+        try {
+            const payload = {
+                timestamp: metadata.timestamp,
+                level,
+                message,
+                prefix: metadata.prefix,
+                location: metadata.stackInfo,
+                additional: args.slice(1),
+            };
+
+            await fetch(this.endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this.apiKey && { 'Authorization': `Bearer ${this.apiKey}` }),
+                },
+                body: JSON.stringify(payload),
+            });
+        } catch (error) {
+            // Silently fail to avoid infinite logging loops
+        }
+    }
+}

package/src/handlers/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Log handlers exports for Advanced Logger
+ */
+
+export { FileLogHandler } from './FileLogHandler.js';
+export { RemoteLogHandler } from './RemoteLogHandler.js';
+export { AnalyticsLogHandler } from './AnalyticsLogHandler.js';
+export { ExportLogHandler } from './ExportLogHandler.js';

package/src/index.ts

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Advanced Logger - Main exports
+ * @version 2.0.0
+ */
+
+// Main Logger class and default instance
+export { Logger } from './Logger.js';
+export { default } from './Logger.js';
+
+// Individual logger method exports for convenience (bound to default instance)
+import defaultLogger from './Logger.js';
+
+export const debug = (...args: any[]) => defaultLogger.debug(...args);
+export const info = (...args: any[]) => defaultLogger.info(...args);
+export const warn = (...args: any[]) => defaultLogger.warn(...args);
+export const error = (...args: any[]) => defaultLogger.error(...args);
+export const success = (...args: any[]) => defaultLogger.success(...args);
+export const trace = (...args: any[]) => defaultLogger.trace(...args);
+export const critical = (...args: any[]) => defaultLogger.critical(...args);
+export const table = (data: any, columns?: string[]) => defaultLogger.table(data, columns);
+export const group = (label: string, collapsed?: boolean) => defaultLogger.group(label, collapsed);
+export const groupEnd = () => defaultLogger.groupEnd();
+export const time = (label: string) => defaultLogger.time(label);
+export const timeEnd = (label: string) => defaultLogger.timeEnd(label);
+export const setGlobalPrefix = (prefix: string) => defaultLogger.setGlobalPrefix(prefix);
+export const createScopedLogger = (prefix: string) => defaultLogger.createScopedLogger(prefix);
+export const setVerbosity = (level: any) => defaultLogger.setVerbosity(level);
+export const addHandler = (handler: any) => defaultLogger.addHandler(handler);
+export const setTheme = (theme: any) => defaultLogger.setTheme(theme);
+export const setBannerType = (bannerType: any) => defaultLogger.setBannerType(bannerType);
+export const showBanner = (bannerType?: any) => defaultLogger.showBanner(bannerType);
+export const logWithSVG = (message: string, svgContent?: string, options?: any) => 
+    defaultLogger.logWithSVG(message, svgContent, options);
+export const logAnimated = (message: string, duration?: number) => 
+    defaultLogger.logAnimated(message, duration);
+export const cli = (command: string) => defaultLogger.cli(command);
+
+// Type exports
+export type {
+    LogLevel,
+    Verbosity,
+    ThemeVariant,
+    BannerType,
+    ExportFormat,
+    LoggerConfig,
+    ILogHandler,
+    LogMetadata,
+    LogEntry,
+    ExportFilters,
+    ExportOptions,
+    ExportResult,
+    BufferStats,
+    StackInfo,
+    TimerEntry,
+    StyleOptions
+} from './types/index.js';
+
+// Styling utilities
+export { 
+    StyleBuilder, 
+    $, 
+    StylePresets,
+    THEME_PRESETS,
+    BANNER_VARIANTS,
+    THEME_BANNERS
+} from './styling/index.js';
+
+// Handler exports
+export {
+    FileLogHandler,
+    RemoteLogHandler,
+    AnalyticsLogHandler,
+    ExportLogHandler
+} from './handlers/index.js';
+
+// CLI exports
+export {
+    CommandProcessor,
+    createDefaultCLI,
+    type ICommand
+} from './cli/index.js';
+
+// Constants
+export { 
+    DEFAULT_CONFIG,
+    BUFFER_LIMITS,
+    EXPORT_FORMATS,
+    CLI_COMMANDS,
+    TIME_UNITS
+} from './constants.js';
+
+// Utility exports
+export {
+    parseStackTrace,
+    formatTimestamp,
+    parseTimeInput,
+    parseRelativeTime,
+    formatDisplayTime,
+    generateLogId,
+    escapeHtml,
+    safeStringify
+} from './utils/index.js';
+
+// Legacy Styles export for backward compatibility
+import { StyleBuilder, StylePresets } from './styling/index.js';
+
+/**
+ * Advanced styling utilities for external use (legacy compatibility)
+ */
+export const Styles = {
+    /**
+     * Creates a new StyleBuilder instance
+     */
+    create(): StyleBuilder {
+        return new StyleBuilder();
+    },
+
+    /**
+     * Pre-defined common styles
+     */
+    presets: StylePresets,
+};