@mks2508/better-logger 2.1.0 → 3.1.0

package/src/terminal/terminal-renderer.ts

@@ -5,6 +5,7 @@
 
 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;
@@ -17,32 +18,19 @@ export type ANSIStyle = {
 };
 
 export class TerminalRenderer {
-    private colorCapability: 'full' | 'basic' | 'none';
+    private colorCapability: ColorCapability;
 
-    constructor(colorCapability: 'full' | 'basic' | 'none' = 'full') {
+    constructor(colorCapability: ColorCapability = 'full') {
         this.colorCapability = colorCapability;
     }
 
     /**
-     * Get ANSI color codes for basic colors
+     * Get ANSI color codes - now supports truecolor/256-color
      */
     private getColorCode(color: string, background: boolean = false): string {
-        const colorCodes: Record<string, { normal: string; bright: string }> = {
-            'black': { normal: '30', bright: '90' },
-            'red': { normal: '31', bright: '91' },
-            'green': { normal: '32', bright: '92' },
-            'yellow': { normal: '33', bright: '93' },
-            'blue': { normal: '34', bright: '94' },
-            'magenta': { normal: '35', bright: '95' },
-            'cyan': { normal: '36', bright: '96' },
-            'white': { normal: '37', bright: '97' },
-            'gray': { normal: '90', bright: '37' },
-            'grey': { normal: '90', bright: '37' }
-        };
-
-        const codes = colorCodes[color.toLowerCase()] || { normal: '37', bright: '97' };
-        const prefix = background ? '4' : '3';
-        return `\x1b[${codes.normal}m`;
+        return background
+            ? getANSIBackground(color, this.colorCapability)
+            : getANSIForeground(color, this.colorCapability);
     }
 
     /**
@@ -207,7 +195,7 @@ export class TerminalRenderer {
     }
 
     /**
-     * Create cyberpunk-style ANSI rendering
+     * Create cyberpunk-style ANSI rendering with truecolor support
      */
     renderCyberpunk(
         level: LogLevel,
@@ -216,35 +204,36 @@ export class TerminalRenderer {
         prefix?: string,
         location?: string
     ): ANSIStyle {
-        const reset = '\x1b[0m';
-        const levelColors: Record<LogLevel, string> = {
-            'debug': '\x1b[95m', // Bright magenta
-            'info': '\x1b[94m',  // Bright blue
-            'warn': '\x1b[93m',  // Bright yellow
-            'error': '\x1b[91m', // Bright red
-            'critical': '\x1b[91m\x1b[1m' // Bright red + bold
+        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(`\x1b[90m${timestamp}${reset}`);
+            parts.push(`${ANSI.dim}${timestamp}${reset}`);
         }
 
-        // Cyberpunk level styling
-        const levelColor = levelColors[level] || '\x1b[97m';
-        const bgBlack = '\x1b[40m';
-        parts.push(`${bgBlack}${levelColor} ${this.getLevelText(level)} ${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 bgBlack = '\x1b[40m';
-            parts.push(`${bgBlack}\x1b[96m[${prefix.toUpperCase()}]${reset}`);
+            const cyanColor = this.getColorCode('#00ffff');
+            parts.push(`${bgBlack}${cyanColor}[${prefix.toUpperCase()}]${reset}`);
         }
 
         parts.push(message);
 
         if (location) {
-            parts.push(`\x1b[90m(${location})${reset}`);
+            parts.push(`${ANSI.dim}(${location})${reset}`);
         }
 
         return {
@@ -254,7 +243,7 @@ export class TerminalRenderer {
     }
 
     /**
-     * Create minimal ANSI rendering
+     * Create minimal ANSI rendering with truecolor support
      */
     renderMinimal(
         level: LogLevel,
@@ -262,26 +251,29 @@ export class TerminalRenderer {
         timestamp?: string,
         prefix?: string
     ): ANSIStyle {
-        const reset = '\x1b[0m';
-        const levelColors: Record<LogLevel, string> = {
-            'debug': '\x1b[95m', // Magenta
-            'info': '\x1b[94m',  // Blue
-            'warn': '\x1b[93m',  // Yellow
-            'error': '\x1b[91m', // Red
-            'critical': '\x1b[91m\x1b[1m' // Red + bold
+        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(`\x1b[90m${timestamp}${reset}`);
+            parts.push(`${ANSI.dim}${timestamp}${reset}`);
         }
 
-        const levelColor = levelColors[level] || '\x1b[97m';
-        parts.push(`${levelColor}${this.getLevelText(level)}:${reset}`);
+        const levelColor = this.getColorCode(minimalColors[level] || '#abb2bf');
+        const bold = level === 'critical' ? ANSI.bold : '';
+        parts.push(`${levelColor}${bold}${this.getLevelText(level)}:${reset}`);
 
         if (prefix) {
-            parts.push(`\x1b[96m[${prefix.toUpperCase()}]${reset}`);
+            const cyanColor = this.getColorCode('#56b6c2');
+            parts.push(`${cyanColor}[${prefix.toUpperCase()}]${reset}`);
         }
 
         parts.push(message);
@@ -293,55 +285,58 @@ export class TerminalRenderer {
     }
 
     /**
-     * Get chalk instance for log level (for compatibility with adapter)
+     * Get chalk-like interface for log level with truecolor support
      */
-    public getChalkForLevel(level: LogLevel): any {
+    public getChalkForLevel(level: LogLevel): ChalkLikeInterface {
         const levelColors: Record<LogLevel, string> = {
-            'debug': 'magenta',
-            'info': 'blue',
-            'warn': 'yellow',
-            'error': 'red',
-            'critical': 'red'
+            'debug': '#c678dd',
+            'info': '#61afef',
+            'warn': '#e5c07b',
+            'error': '#e06c75',
+            'critical': '#be5046'
         };
 
+        const reset = ANSI.reset;
+
         return {
             color: (text: string) => {
-                const color = levelColors[level] || 'white';
+                const color = levelColors[level] || '#abb2bf';
                 const colorCode = this.getColorCode(color);
-                return `${colorCode}${text}${'\x1b[0m'}`;
-            },
-            bold: (text: string) => {
-                const boldStyle = this.getStyleCode(['bold']);
-                return `${boldStyle}${text}${'\x1b[0m'}`;
-            },
-            dim: (text: string) => {
-                const dimStyle = this.getStyleCode(['dim']);
-                return `${dimStyle}${text}${'\x1b[0m'}`;
-            },
-            bgGray: (text: string) => {
-                return `\x1b[100m${text}${'\x1b[0m'}`;
-            },
-            bgBlue: (text: string) => {
-                return `\x1b[104m${text}${'\x1b[0m'}`;
+                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('cyan');
-                    const bold = this.getStyleCode(['bold']);
-                    return `${cyan}${bold}${text}${'\x1b[0m'}`;
+                    const cyan = this.getColorCode('#00ffff');
+                    return `${cyan}${ANSI.bold}${text}${reset}`;
                 },
                 dim: (text: string) => {
-                    const cyan = this.getColorCode('cyan');
-                    const dim = this.getStyleCode(['dim']);
-                    return `${cyan}${dim}${text}${'\x1b[0m'}`;
+                    const cyan = this.getColorCode('#00ffff');
+                    return `${cyan}${ANSI.dim}${text}${reset}`;
                 },
                 bg: (text: string) => {
-                    const bgBlack = '\x1b[40m';
-                    const cyan = this.getColorCode('cyan');
-                    return `${bgBlack}${cyan}[${text.toUpperCase()}]${'\x1b[0m'}`;
+                    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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,130 @@
+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

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

package/src/types/core.ts

@@ -247,4 +247,72 @@ export interface LogStyles {
     location?: LogPartConfig;
     backdrop?: string;
     transparency?: number;
+}
+
+export interface TimerResult {
+    label: string;
+    duration: number;
+    startTime: number;
+    endTime: number;
+}
+
+export interface IScopedLogger {
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    success(...args: any[]): void;
+    critical(...args: any[]): void;
+    trace(...args: any[]): void;
+
+    badges(badges: string[]): this;
+    badge(badge: string): this;
+    clearBadges(): this;
+
+    time(label: string): void;
+    timeEnd(label: string): number | undefined;
+
+    style(presetName: string): this;
+}
+
+export interface IAPILogger extends IScopedLogger {
+    slow(message: string, duration?: number): void;
+    rateLimit(message: string): void;
+    auth(message: string): void;
+    deprecated(message: string): void;
+}
+
+export interface IComponentLogger extends IScopedLogger {
+    lifecycle(event: string, message?: string): void;
+    stateChange(from: string, to: string, data?: any): void;
+    propsChange(changes: Record<string, any>): void;
+}
+
+export interface Bindings {
+    scope?: string;
+    badges?: string[];
+    type?: 'scope' | 'api' | 'component';
+    context?: string[];
+}
+
+export type BadgeStyle = 'brackets' | 'rounded' | 'plain' | 'unicode' | 'pill';
+
+export type TimestampFormat = 'iso' | 'time' | 'timeMs' | 'relative' | 'elapsed' | 'date' | 'custom';
+
+export type ColumnAlign = 'left' | 'right' | 'center';
+
+export interface ColumnConfig {
+    content: string;
+    width?: number;
+    align?: ColumnAlign;
+    color?: string;
+}
+
+export interface LogOptions {
+    rightAlign?: string;
+    columns?: ColumnConfig[];
+    maxWidth?: number;
+    keyValue?: boolean;
+    badgeStyle?: BadgeStyle;
+    timestampFormat?: TimestampFormat;
 }

package/src/types/hooks.ts

@@ -0,0 +1,45 @@
+import type { LogLevel, StackInfo } from './core.js';
+
+export interface HookLogEntry {
+    level: LogLevel;
+    message: string;
+    args: any[];
+    timestamp: string;
+    prefix?: string;
+    stackInfo?: StackInfo;
+    correlationId?: string;
+    context?: Record<string, any>;
+    [key: string]: any;
+}
+
+export type HookEvent = 'beforeLog' | 'afterLog' | 'onError';
+
+export type HookCallback = (entry: HookLogEntry) => void | HookLogEntry | Promise<void | HookLogEntry>;
+
+export type MiddlewareFn = (
+    entry: HookLogEntry,
+    next: () => void | Promise<void>
+) => void | Promise<void>;
+
+export interface HookRegistration {
+    id: string;
+    event: HookEvent;
+    callback: HookCallback;
+    priority: number;
+    once: boolean;
+}
+
+export interface MiddlewareRegistration {
+    id: string;
+    fn: MiddlewareFn;
+    priority: number;
+}
+
+export interface IHookManager {
+    on(event: HookEvent, callback: HookCallback, priority?: number): () => void;
+    once(event: HookEvent, callback: HookCallback, priority?: number): () => void;
+    off(event: HookEvent, callback: HookCallback): boolean;
+    use(middleware: MiddlewareFn, priority?: number): () => void;
+    emit(event: HookEvent, entry: HookLogEntry): Promise<HookLogEntry>;
+    process(entry: HookLogEntry): Promise<HookLogEntry>;
+}