@mks2508/better-logger 5.0.0 → 5.0.2

package/src/terminal/terminal-renderer.ts

@@ -1,342 +0,0 @@
-/**
- * Terminal Renderer - ANSI color rendering for terminal environments
- * Converts CSS-based styling to ANSI escape sequences for terminal output
- */
-
-import type { LogLevel } from '../types/index.js';
-import type { LogStyles } from '../types/index.js';
-import { getANSIForeground, getANSIBackground, ANSI, type ColorCapability } from './color-converter.js';
-
-export type ANSIStyle = {
-    text: string;
-    timestamp?: string;
-    level?: string;
-    prefix?: string;
-    message?: string;
-    location?: string;
-    reset: string;
-};
-
-export class TerminalRenderer {
-    private colorCapability: ColorCapability;
-
-    constructor(colorCapability: ColorCapability = 'full') {
-        this.colorCapability = colorCapability;
-    }
-
-    /**
-     * Get ANSI color codes - now supports truecolor/256-color
-     */
-    private getColorCode(color: string, background: boolean = false): string {
-        return background
-            ? getANSIBackground(color, this.colorCapability)
-            : getANSIForeground(color, this.colorCapability);
-    }
-
-    /**
-     * Get ANSI style codes
-     */
-    private getStyleCode(styles: string[]): string {
-        const styleCodes: Record<string, string> = {
-            'bold': '1',
-            'dim': '2',
-            'italic': '3',
-            'underline': '4',
-            'reset': '0'
-        };
-
-        const codes = styles.map(style => styleCodes[style] || '0').join(';');
-        return codes ? `\x1b[${codes}m` : '';
-    }
-
-    /**
-     * Convert log styles to ANSI formatting
-     */
-    renderTerminal(
-        level: LogLevel,
-        message: string,
-        timestamp?: string,
-        prefix?: string,
-        location?: string,
-        styles?: LogStyles
-    ): ANSIStyle {
-        const reset = '\x1b[0m';
-        const result: ANSIStyle = { text: '', reset };
-
-        // Apply preset styles if provided
-        if (styles) {
-            result.timestamp = this.styleTimestamp(timestamp, styles.timestamp);
-            result.level = this.styleLevel(level, styles.level);
-            result.prefix = this.stylePrefix(prefix, styles.prefix);
-            result.message = this.styleMessage(message, styles.message);
-            result.location = this.styleLocation(location, styles.location);
-        } else {
-            // Default styling based on level
-            result.timestamp = this.styleTimestamp(timestamp);
-            result.level = this.styleLevel(level);
-            result.prefix = this.stylePrefix(prefix);
-            result.message = this.styleMessage(message);
-            result.location = this.styleLocation(location);
-        }
-
-        // Build complete text
-        const parts: string[] = [];
-        if (result.timestamp) parts.push(result.timestamp);
-        if (result.level) parts.push(result.level);
-        if (result.prefix) parts.push(result.prefix);
-        if (result.message) parts.push(result.message);
-        if (result.location) parts.push(result.location);
-
-        result.text = parts.join(' ') + reset;
-        return result;
-    }
-
-    /**
-     * Style timestamp based on preset or defaults
-     */
-    private styleTimestamp(timestamp?: string, style?: LogStyles['timestamp']): string {
-        if (!timestamp || !style?.show) return '';
-
-        if (this.colorCapability === 'none') {
-            return timestamp;
-        }
-
-        const dimStyle = this.getStyleCode(['dim']);
-        return `${dimStyle}${timestamp}${'\x1b[0m'}`;
-    }
-
-    /**
-     * Style level with appropriate colors and formatting
-     */
-    private styleLevel(level: LogLevel, style?: LogStyles['level']): string {
-        if (!style?.show) return '';
-
-        const levelText = this.getLevelText(level);
-        const levelColors: Record<LogLevel, string> = {
-            'debug': 'magenta',
-            'info': 'blue',
-            'warn': 'yellow',
-            'error': 'red',
-            'critical': 'red'
-        };
-
-        if (this.colorCapability === 'none') {
-            return `[${levelText}]`;
-        }
-
-        const color = levelColors[level] || 'white';
-        const colorCode = this.getColorCode(color);
-        const boldStyle = this.getStyleCode(['bold']);
-
-        if (style?.style === 'compact') {
-            return `${colorCode}[${levelText}]${'\x1b[0m'}`;
-        } else {
-            return `${colorCode}${boldStyle}[${levelText}]${'\x1b[0m'}`;
-        }
-    }
-
-    /**
-     * Style prefix based on preset - now as a badge
-     */
-    private stylePrefix(prefix?: string, style?: LogStyles['prefix']): string {
-        if (!prefix || !style?.show) return '';
-
-        if (this.colorCapability === 'none') {
-            return `[${prefix}]`;
-        }
-
-        // Create badge styling similar to level badges
-        const colorCode = this.getColorCode('cyan');
-        const bgBlack = '\x1b[40m';
-        return `${bgBlack}${colorCode}[${prefix.toUpperCase()}]${'\x1b[0m'}`;
-    }
-
-    /**
-     * Style message based on preset
-     */
-    private styleMessage(message: string, style?: LogStyles['message']): string {
-        if (!style?.show) return message;
-
-        return message; // Messages usually don't need styling
-    }
-
-    /**
-     * Style location (file:line) information
-     */
-    private styleLocation(location?: string, style?: LogStyles['location']): string {
-        if (!location || !style?.show) return '';
-
-        if (this.colorCapability === 'none') {
-            return `(${location})`;
-        }
-
-        const dimStyle = this.getStyleCode(['dim']);
-        if (style?.style === 'clickable') {
-            const underlineStyle = this.getStyleCode(['dim', 'underline']);
-            return `${underlineStyle}(${location})${'\x1b[0m'}`;
-        }
-
-        return `${dimStyle}(${location})${'\x1b[0m'}`;
-    }
-
-    /**
-     * Get text representation of log level
-     */
-    public getLevelText(level: LogLevel): string {
-        const levelMap: Record<LogLevel, string> = {
-            'debug': 'DEBUG',
-            'info': 'INFO',
-            'warn': 'WARN',
-            'error': 'ERROR',
-            'critical': 'CRITICAL'
-        };
-
-        return levelMap[level] || String(level).toUpperCase();
-    }
-
-    /**
-     * Create cyberpunk-style ANSI rendering with truecolor support
-     */
-    renderCyberpunk(
-        level: LogLevel,
-        message: string,
-        timestamp?: string,
-        prefix?: string,
-        location?: string
-    ): ANSIStyle {
-        const reset = ANSI.reset;
-
-        const cyberpunkColors: Record<LogLevel, string> = {
-            'debug': '#ff00ff',   // Neon magenta
-            'info': '#00ffff',    // Neon cyan
-            'warn': '#ffff00',    // Neon yellow
-            'error': '#ff0040',   // Neon red-pink
-            'critical': '#ff0000' // Pure red
-        };
-
-        const parts: string[] = [];
-
-        if (timestamp) {
-            parts.push(`${ANSI.dim}${timestamp}${reset}`);
-        }
-
-        const levelColor = this.getColorCode(cyberpunkColors[level] || '#ffffff');
-        const bgBlack = ANSI.bg.black;
-        const bold = level === 'critical' ? ANSI.bold : '';
-        parts.push(`${bgBlack}${levelColor}${bold} ${this.getLevelText(level)} ${reset}`);
-
-        if (prefix) {
-            const cyanColor = this.getColorCode('#00ffff');
-            parts.push(`${bgBlack}${cyanColor}[${prefix.toUpperCase()}]${reset}`);
-        }
-
-        parts.push(message);
-
-        if (location) {
-            parts.push(`${ANSI.dim}(${location})${reset}`);
-        }
-
-        return {
-            text: parts.join(' '),
-            reset
-        };
-    }
-
-    /**
-     * Create minimal ANSI rendering with truecolor support
-     */
-    renderMinimal(
-        level: LogLevel,
-        message: string,
-        timestamp?: string,
-        prefix?: string
-    ): ANSIStyle {
-        const reset = ANSI.reset;
-
-        const minimalColors: Record<LogLevel, string> = {
-            'debug': '#c678dd', // Soft purple
-            'info': '#61afef',  // Soft blue
-            'warn': '#e5c07b',  // Soft yellow
-            'error': '#e06c75', // Soft red
-            'critical': '#be5046' // Dark red
-        };
-
-        const parts: string[] = [];
-
-        if (timestamp) {
-            parts.push(`${ANSI.dim}${timestamp}${reset}`);
-        }
-
-        const levelColor = this.getColorCode(minimalColors[level] || '#abb2bf');
-        const bold = level === 'critical' ? ANSI.bold : '';
-        parts.push(`${levelColor}${bold}${this.getLevelText(level)}:${reset}`);
-
-        if (prefix) {
-            const cyanColor = this.getColorCode('#56b6c2');
-            parts.push(`${cyanColor}[${prefix.toUpperCase()}]${reset}`);
-        }
-
-        parts.push(message);
-
-        return {
-            text: parts.join(' '),
-            reset
-        };
-    }
-
-    /**
-     * Get chalk-like interface for log level with truecolor support
-     */
-    public getChalkForLevel(level: LogLevel): ChalkLikeInterface {
-        const levelColors: Record<LogLevel, string> = {
-            'debug': '#c678dd',
-            'info': '#61afef',
-            'warn': '#e5c07b',
-            'error': '#e06c75',
-            'critical': '#be5046'
-        };
-
-        const reset = ANSI.reset;
-
-        return {
-            color: (text: string) => {
-                const color = levelColors[level] || '#abb2bf';
-                const colorCode = this.getColorCode(color);
-                return `${colorCode}${text}${reset}`;
-            },
-            bold: (text: string) => `${ANSI.bold}${text}${reset}`,
-            dim: (text: string) => `${ANSI.dim}${text}${reset}`,
-            bgGray: (text: string) => `${ANSI.bg.gray}${text}${reset}`,
-            bgBlue: (text: string) => `${this.getColorCode('#1e3a5f', true)}${text}${reset}`,
-            reset: (text: string) => text,
-            cyan: {
-                bold: (text: string) => {
-                    const cyan = this.getColorCode('#00ffff');
-                    return `${cyan}${ANSI.bold}${text}${reset}`;
-                },
-                dim: (text: string) => {
-                    const cyan = this.getColorCode('#00ffff');
-                    return `${cyan}${ANSI.dim}${text}${reset}`;
-                },
-                bg: (text: string) => {
-                    const cyan = this.getColorCode('#00ffff');
-                    return `${ANSI.bg.black}${cyan}[${text.toUpperCase()}]${reset}`;
-                }
-            }
-        };
-    }
-}
-
-export interface ChalkLikeInterface {
-    color: (text: string) => string;
-    bold: (text: string) => string;
-    dim: (text: string) => string;
-    bgGray: (text: string) => string;
-    bgBlue: (text: string) => string;
-    reset: (text: string) => string;
-    cyan: {
-        bold: (text: string) => string;
-        dim: (text: string) => string;
-        bg: (text: string) => string;
-    };
-}

package/src/transports/ConsoleTransport.ts

@@ -1,28 +0,0 @@
-import type { TransportRecord, TransportOptions, ITransport, LogLevel } from '../types/index.js';
-
-export class ConsoleTransport implements ITransport {
-    readonly name = 'console';
-
-    constructor(private options?: TransportOptions) {}
-
-    write(record: TransportRecord): void {
-        const method = this.getConsoleMethod(record.level);
-        const prefix = record.prefix ? `[${record.prefix}] ` : '';
-        const location = record.location
-            ? ` (${record.location.file}:${record.location.line})`
-            : '';
-
-        console[method](`[${record.level.toUpperCase()}]${prefix} ${record.msg}${location}`);
-    }
-
-    private getConsoleMethod(level: LogLevel): 'log' | 'info' | 'warn' | 'error' {
-        switch (level) {
-            case 'debug': return 'log';
-            case 'info': return 'info';
-            case 'warn': return 'warn';
-            case 'error':
-            case 'critical': return 'error';
-            default: return 'log';
-        }
-    }
-}

package/src/transports/FileTransport.ts

@@ -1,53 +0,0 @@
-import type { TransportRecord, TransportOptions, ITransport } from '../types/index.js';
-
-export interface FileTransportOptions extends TransportOptions {
-    destination?: string;
-}
-
-export class FileTransport implements ITransport {
-    readonly name = 'file';
-    private buffer: string[] = [];
-    private flushTimer?: ReturnType<typeof setInterval>;
-    private options: FileTransportOptions;
-
-    constructor(options?: FileTransportOptions) {
-        this.options = options || {};
-
-        if (this.options.flushInterval) {
-            this.flushTimer = setInterval(() => this.flush(), this.options.flushInterval);
-        }
-    }
-
-    write(record: TransportRecord): void {
-        const line = JSON.stringify(record) + '\n';
-        this.buffer.push(line);
-
-        if (this.buffer.length >= (this.options.batchSize || 100)) {
-            this.flush();
-        }
-    }
-
-    async flush(): Promise<void> {
-        if (this.buffer.length === 0) return;
-
-        const lines = this.buffer.join('');
-        this.buffer = [];
-
-        if (typeof globalThis.process !== 'undefined' && typeof require === 'function') {
-            try {
-                const fs = require('fs');
-                const dest = this.options.destination || 'app.log';
-                fs.appendFileSync(dest, lines);
-            } catch {
-                // Silent fail in browser or if fs not available
-            }
-        }
-    }
-
-    close(): void {
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-        }
-        this.flush();
-    }
-}

package/src/transports/HttpTransport.ts

@@ -1,56 +0,0 @@
-import type { TransportRecord, TransportOptions, ITransport } from '../types/index.js';
-
-export interface HttpTransportOptions extends TransportOptions {
-    url?: string;
-    headers?: Record<string, string>;
-}
-
-export class HttpTransport implements ITransport {
-    readonly name = 'http';
-    private buffer: TransportRecord[] = [];
-    private flushTimer?: ReturnType<typeof setInterval>;
-    private options: HttpTransportOptions;
-
-    constructor(options?: HttpTransportOptions) {
-        this.options = options || {};
-
-        if (this.options.flushInterval) {
-            this.flushTimer = setInterval(() => this.flush(), this.options.flushInterval);
-        }
-    }
-
-    write(record: TransportRecord): void {
-        this.buffer.push(record);
-
-        if (this.buffer.length >= (this.options.batchSize || 50)) {
-            this.flush();
-        }
-    }
-
-    async flush(): Promise<void> {
-        if (this.buffer.length === 0 || !this.options.url) return;
-
-        const records = [...this.buffer];
-        this.buffer = [];
-
-        try {
-            await fetch(this.options.url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.options.headers
-                },
-                body: JSON.stringify({ logs: records })
-            });
-        } catch {
-            this.buffer.unshift(...records);
-        }
-    }
-
-    close(): void {
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-        }
-        this.flush();
-    }
-}

package/src/transports/TransportManager.ts

@@ -1,130 +0,0 @@
-import type {
-    TransportRecord,
-    TransportTarget,
-    TransportOptions,
-    ITransport,
-    ITransportManager,
-    LogLevel
-} from '../types/index.js';
-import { LOG_LEVELS } from '../types/index.js';
-
-function generateTransportId(): string {
-    return `transport-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-}
-
-interface TransportEntry {
-    id: string;
-    transport: ITransport;
-    options: TransportOptions;
-    level: LogLevel;
-    levelValue: number;
-}
-
-export class TransportManager implements ITransportManager {
-    private transports: Map<string, TransportEntry> = new Map();
-    private defaultLevel: LogLevel = 'info';
-
-    constructor(defaultLevel?: LogLevel) {
-        if (defaultLevel) {
-            this.defaultLevel = defaultLevel;
-        }
-    }
-
-    add(target: TransportTarget): string {
-        const id = generateTransportId();
-        const level = target.level || this.defaultLevel;
-
-        let transport: ITransport;
-
-        if (typeof target.target === 'string') {
-            throw new Error(`String transport targets not supported. Use inline transport object.`);
-        } else {
-            transport = target.target;
-        }
-
-        const entry: TransportEntry = {
-            id,
-            transport,
-            options: target.options || {},
-            level,
-            levelValue: LOG_LEVELS[level]
-        };
-
-        this.transports.set(id, entry);
-        return id;
-    }
-
-    remove(id: string): boolean {
-        const entry = this.transports.get(id);
-        if (entry) {
-            entry.transport.close?.();
-            return this.transports.delete(id);
-        }
-        return false;
-    }
-
-    async write(record: TransportRecord): Promise<void> {
-        const promises: Promise<void>[] = [];
-
-        for (const entry of this.transports.values()) {
-            if (record.levelValue < entry.levelValue) {
-                continue;
-            }
-
-            let transformedRecord = record;
-            if (entry.options.transform) {
-                const result = entry.options.transform(record);
-                if (result === null) continue;
-                transformedRecord = result;
-            }
-
-            const result = entry.transport.write(transformedRecord);
-            if (result instanceof Promise) {
-                promises.push(result);
-            }
-        }
-
-        await Promise.all(promises);
-    }
-
-    async flush(): Promise<void> {
-        const promises: Promise<void>[] = [];
-
-        for (const entry of this.transports.values()) {
-            if (entry.transport.flush) {
-                const result = entry.transport.flush();
-                if (result instanceof Promise) {
-                    promises.push(result);
-                }
-            }
-        }
-
-        await Promise.all(promises);
-    }
-
-    async close(): Promise<void> {
-        await this.flush();
-
-        const promises: Promise<void>[] = [];
-
-        for (const entry of this.transports.values()) {
-            if (entry.transport.close) {
-                const result = entry.transport.close();
-                if (result instanceof Promise) {
-                    promises.push(result);
-                }
-            }
-        }
-
-        await Promise.all(promises);
-        this.transports.clear();
-    }
-
-    get count(): number {
-        return this.transports.size;
-    }
-
-    list(): string[] {
-        return Array.from(this.transports.keys());
-    }
-}

package/src/transports/index.ts

@@ -1,4 +0,0 @@
-export { TransportManager } from './TransportManager.js';
-export { ConsoleTransport } from './ConsoleTransport.js';
-export { FileTransport, type FileTransportOptions } from './FileTransport.js';
-export { HttpTransport, type HttpTransportOptions } from './HttpTransport.js';