@mks2508/better-logger 2.1.0 → 3.1.0

package/src/index.ts

@@ -98,7 +98,12 @@ 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 scope = (name: string) => getLogger().scope(name);
+export const component = (name: string) => getLogger().component(name);
+export const api = (name: string) => getLogger().api(name);
+export const badges = (badgeList: string[]) => getLogger().badges(badgeList);
+export const badge = (badgeName: string) => getLogger().badge(badgeName);
+export const clearBadges = () => getLogger().clearBadges();
 export const setVerbosity = (level: Verbosity) => getLogger().setVerbosity(level);
 export const addHandler = (handler: ILogHandler) => getLogger().addHandler(handler);
 export const setTheme = (theme: ThemeVariant) => getLogger().setTheme(theme);
@@ -122,7 +127,31 @@ export type {
     LogMetadata,
     StackInfo,
     TimerEntry,
-    OutputFormat
+    TimerResult,
+    OutputFormat,
+    IScopedLogger,
+    IAPILogger,
+    IComponentLogger,
+    Bindings,
+    SerializerFn,
+    SerializerContext,
+    SerializerConfig,
+    ISerializerRegistry,
+    HookLogEntry,
+    HookEvent,
+    HookCallback,
+    MiddlewareFn,
+    IHookManager,
+    TransportRecord,
+    TransportOptions,
+    TransportTarget,
+    ITransport,
+    StyleCacheConfig,
+    BadgeStyle,
+    TimestampFormat,
+    ColumnAlign,
+    ColumnConfig,
+    LogOptions,
 } from './types/index.js';
 
 // Styling utilities
@@ -141,6 +170,57 @@ export {
     AnalyticsLogHandler
 } from './handlers/index.js';
 
+// Serializers
+export { SerializerRegistry } from './serializers/index.js';
+
+// Hooks & Middleware
+export { HookManager } from './hooks/index.js';
+
+// Transports
+export {
+    TransportManager,
+    ConsoleTransport,
+    FileTransport,
+    HttpTransport
+} from './transports/index.js';
+
+// Style Cache
+export { StyleCache, getStyleCache } from './styling/StyleCache.js';
+
+// Enterprise feature function exports
+import type { SerializerFn, HookEvent, HookCallback, MiddlewareFn, TransportTarget } from './types/index.js';
+export const addSerializer = <T>(
+    type: new (...args: any[]) => T,
+    serializer: SerializerFn<T>,
+    priority?: number
+) => getLogger().addSerializer(type, serializer, priority);
+export const removeSerializer = <T>(type: new (...args: any[]) => T) =>
+    getLogger().removeSerializer(type);
+export const on = (event: HookEvent, callback: HookCallback, priority?: number) =>
+    getLogger().on(event, callback, priority);
+export const once = (event: HookEvent, callback: HookCallback, priority?: number) =>
+    getLogger().once(event, callback, priority);
+export const off = (event: HookEvent, callback: HookCallback) =>
+    getLogger().off(event, callback);
+export const use = (middleware: MiddlewareFn, priority?: number) =>
+    getLogger().use(middleware, priority);
+export const addTransport = (target: TransportTarget) =>
+    getLogger().addTransport(target);
+export const removeTransport = (id: string) =>
+    getLogger().removeTransport(id);
+export const flushTransports = () =>
+    getLogger().flushTransports();
+export const closeTransports = () =>
+    getLogger().closeTransports();
+
+// Scoped loggers
+export {
+    ScopedLogger,
+    APILogger,
+    ComponentLogger,
+    ContextLogger
+} from './ScopedLogger.js';
+
 // Constants
 export { DEFAULT_CONFIG } from './constants.js';
 
@@ -241,4 +321,54 @@ export const stylePresets = {
     warning: StylePresets.warning().build(),
     info: StylePresets.info().build(),
     accent: StylePresets.accent().build(),
-};
+};
+
+// Terminal formatting utilities
+export {
+    formatWithRightAlign,
+    formatColumns,
+    formatKeyValue,
+    formatBadge,
+    formatTimestamp as formatTimestampExt,
+    formatRelativeTime,
+    formatElapsedTime,
+    resetStartTime,
+    isKeyValueObject,
+    stripAnsi,
+    getVisibleLength,
+    padToWidth,
+    applyLogOptions,
+} from './terminal/formatter.js';
+
+// Color converter utilities
+export {
+    hexToRgb,
+    rgbToHex,
+    hexTo256,
+    colorToHex,
+    getANSIForeground,
+    getANSIBackground,
+    getANSI256Foreground,
+    getANSI256Background,
+    cssColorToANSI,
+    ANSI,
+} from './terminal/color-converter.js';
+
+export type { RGB, ColorCapability } from './terminal/color-converter.js';
+
+// Terminal renderer
+export { TerminalRenderer } from './terminal/terminal-renderer.js';
+export type { ANSIStyle, ChalkLikeInterface } from './terminal/terminal-renderer.js';
+
+// Environment detection
+export {
+    getEnvironment,
+    isRunningInTerminal,
+    supportsANSI,
+    getColorCapability,
+    getTerminalWidth,
+    getTerminalHeight,
+    getEnvironmentInfo,
+} from './utils/environment-detector.js';
+
+export type { Environment } from './utils/environment-detector.js';

package/src/serializers/SerializerRegistry.ts

@@ -0,0 +1,173 @@
+import type {
+    SerializerFn,
+    SerializerContext,
+    SerializerEntry,
+    SerializerConfig,
+    ISerializerRegistry
+} from '../types/index.js';
+
+const DEFAULT_CONFIG: Required<SerializerConfig> = {
+    maxDepth: 5,
+    circular: 'placeholder',
+    preserveUndefined: false
+};
+
+export class SerializerRegistry implements ISerializerRegistry {
+    private serializers: Map<Function, SerializerEntry> = new Map();
+    private config: Required<SerializerConfig>;
+
+    constructor(config: SerializerConfig = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.registerDefaults();
+    }
+
+    private registerDefaults(): void {
+        this.add(Error, (err: Error) => ({
+            name: err.name,
+            message: err.message,
+            stack: err.stack?.split('\n').slice(0, 10),
+            ...(err.cause ? { cause: this.serialize(err.cause) } : {})
+        }), 100);
+
+        this.add(Date, (date: Date) => ({
+            iso: date.toISOString(),
+            timestamp: date.getTime()
+        }), 90);
+
+        this.add(RegExp, (regex: RegExp) => ({
+            pattern: regex.source,
+            flags: regex.flags
+        }), 90);
+
+        this.add(Map, (map: Map<any, any>, ctx) => {
+            const obj: Record<string, any> = {};
+            map.forEach((value, key) => {
+                const keyStr = typeof key === 'object' ? JSON.stringify(key) : String(key);
+                obj[keyStr] = this.serializeInternal(value, {
+                    ...ctx,
+                    depth: ctx.depth + 1,
+                    path: [...ctx.path, keyStr]
+                });
+            });
+            return { __type: 'Map', entries: obj };
+        }, 80);
+
+        this.add(Set, (set: Set<any>, ctx) => ({
+            __type: 'Set',
+            values: Array.from(set).map((v, i) =>
+                this.serializeInternal(v, {
+                    ...ctx,
+                    depth: ctx.depth + 1,
+                    path: [...ctx.path, `[${i}]`]
+                })
+            )
+        }), 80);
+
+        if (typeof Buffer !== 'undefined') {
+            this.add(Buffer as any, (buf: Buffer) => ({
+                __type: 'Buffer',
+                length: buf.length,
+                preview: buf.slice(0, 50).toString('hex')
+            }), 70);
+        }
+    }
+
+    add<T>(
+        type: new (...args: any[]) => T,
+        serializer: SerializerFn<T>,
+        priority: number = 50
+    ): void {
+        this.serializers.set(type, { type, serializer, priority });
+    }
+
+    remove<T>(type: new (...args: any[]) => T): boolean {
+        return this.serializers.delete(type);
+    }
+
+    has<T>(type: new (...args: any[]) => T): boolean {
+        return this.serializers.has(type);
+    }
+
+    getAll(): SerializerEntry[] {
+        return Array.from(this.serializers.values())
+            .sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));
+    }
+
+    private findSerializer(value: any): SerializerEntry | null {
+        const sorted = this.getAll();
+        for (const entry of sorted) {
+            if (value instanceof entry.type) {
+                return entry;
+            }
+        }
+        return null;
+    }
+
+    private serializeInternal(value: any, context: SerializerContext): any {
+        if (value === null) return null;
+        if (value === undefined) return this.config.preserveUndefined ? undefined : '[undefined]';
+        if (typeof value === 'function') return `[Function: ${value.name || 'anonymous'}]`;
+        if (typeof value !== 'object') return value;
+
+        if (context.depth >= this.config.maxDepth) {
+            return '[Max Depth]';
+        }
+
+        if (context.seen.has(value)) {
+            switch (this.config.circular) {
+                case 'error':
+                    throw new Error(`Circular reference at ${context.path.join('.')}`);
+                case 'skip':
+                    return undefined;
+                case 'placeholder':
+                default:
+                    return '[Circular]';
+            }
+        }
+        context.seen.add(value);
+
+        const serializer = this.findSerializer(value);
+        if (serializer) {
+            return serializer.serializer(value, context);
+        }
+
+        if (Array.isArray(value)) {
+            return value.map((item, i) =>
+                this.serializeInternal(item, {
+                    ...context,
+                    depth: context.depth + 1,
+                    path: [...context.path, `[${i}]`]
+                })
+            );
+        }
+
+        const result: Record<string, any> = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = this.serializeInternal(val, {
+                ...context,
+                depth: context.depth + 1,
+                path: [...context.path, key]
+            });
+        }
+        return result;
+    }
+
+    serialize(value: any, config?: SerializerConfig): any {
+        const mergedConfig = { ...this.config, ...config };
+        return this.serializeInternal(value, {
+            depth: 0,
+            maxDepth: mergedConfig.maxDepth,
+            path: [],
+            seen: new WeakSet()
+        });
+    }
+}
+
+let _defaultRegistry: SerializerRegistry | null = null;
+
+export function getDefaultSerializerRegistry(): SerializerRegistry {
+    if (!_defaultRegistry) {
+        _defaultRegistry = new SerializerRegistry();
+    }
+    return _defaultRegistry;
+}

package/src/serializers/index.ts

@@ -0,0 +1 @@
+export { SerializerRegistry, getDefaultSerializerRegistry } from './SerializerRegistry.js';

package/src/styling/StyleCache.ts

@@ -0,0 +1,131 @@
+import type { LogLevel, DevToolsTheme } from '../types/core.js';
+
+interface CacheKey {
+    level: LogLevel | 'success';
+    theme: DevToolsTheme;
+    presetName?: string;
+    hasPrefix: boolean;
+    hasLocation: boolean;
+}
+
+interface CacheEntry {
+    styles: string[];
+    format: string;
+    createdAt: number;
+    hits: number;
+}
+
+export interface StyleCacheConfig {
+    maxEntries?: number;
+    ttl?: number;
+    enabled?: boolean;
+}
+
+const DEFAULT_CONFIG: Required<StyleCacheConfig> = {
+    maxEntries: 100,
+    ttl: 5 * 60 * 1000,
+    enabled: true
+};
+
+export class StyleCache {
+    private cache: Map<string, CacheEntry> = new Map();
+    private config: Required<StyleCacheConfig>;
+    private hitCount = 0;
+    private missCount = 0;
+
+    constructor(config: StyleCacheConfig = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+
+    private generateKey(key: CacheKey): string {
+        return `${key.level}:${key.theme}:${key.presetName || 'default'}:${key.hasPrefix}:${key.hasLocation}`;
+    }
+
+    get(key: CacheKey): CacheEntry | null {
+        if (!this.config.enabled) return null;
+
+        const cacheKey = this.generateKey(key);
+        const entry = this.cache.get(cacheKey);
+
+        if (!entry) {
+            this.missCount++;
+            return null;
+        }
+
+        if (Date.now() - entry.createdAt > this.config.ttl) {
+            this.cache.delete(cacheKey);
+            this.missCount++;
+            return null;
+        }
+
+        entry.hits++;
+        this.cache.delete(cacheKey);
+        this.cache.set(cacheKey, entry);
+        this.hitCount++;
+
+        return entry;
+    }
+
+    set(key: CacheKey, format: string, styles: string[]): void {
+        if (!this.config.enabled) return;
+
+        const cacheKey = this.generateKey(key);
+
+        if (this.cache.size >= this.config.maxEntries) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+
+        this.cache.set(cacheKey, {
+            format,
+            styles: [...styles],
+            createdAt: Date.now(),
+            hits: 0
+        });
+    }
+
+    clear(): void {
+        this.cache.clear();
+        this.hitCount = 0;
+        this.missCount = 0;
+    }
+
+    getStats(): {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+        hits: number;
+        misses: number;
+    } {
+        const total = this.hitCount + this.missCount;
+        return {
+            size: this.cache.size,
+            maxSize: this.config.maxEntries,
+            hitRate: total > 0 ? this.hitCount / total : 0,
+            hits: this.hitCount,
+            misses: this.missCount
+        };
+    }
+
+    setEnabled(enabled: boolean): void {
+        this.config.enabled = enabled;
+        if (!enabled) {
+            this.clear();
+        }
+    }
+
+    isEnabled(): boolean {
+        return this.config.enabled;
+    }
+}
+
+let _styleCache: StyleCache | null = null;
+
+export function getStyleCache(): StyleCache {
+    if (!_styleCache) {
+        _styleCache = new StyleCache();
+    }
+    return _styleCache;
+}