@mks2508/better-logger 5.0.1 → 5.0.2

package/src/serializers/SerializerRegistry.ts

@@ -1,173 +0,0 @@
-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/style.css

@@ -1,96 +0,0 @@
-:root {
-  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
-  line-height: 1.5;
-  font-weight: 400;
-
-  color-scheme: light dark;
-  color: rgba(255, 255, 255, 0.87);
-  background-color: #242424;
-
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-a {
-  font-weight: 500;
-  color: #646cff;
-  text-decoration: inherit;
-}
-a:hover {
-  color: #535bf2;
-}
-
-body {
-  margin: 0;
-  display: flex;
-  place-items: center;
-  min-width: 320px;
-  min-height: 100vh;
-}
-
-h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
-}
-
-#app {
-  max-width: 1280px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-}
-
-.logo {
-  height: 6em;
-  padding: 1.5em;
-  will-change: filter;
-  transition: filter 300ms;
-}
-.logo:hover {
-  filter: drop-shadow(0 0 2em #646cffaa);
-}
-.logo.vanilla:hover {
-  filter: drop-shadow(0 0 2em #3178c6aa);
-}
-
-.card {
-  padding: 2em;
-}
-
-.read-the-docs {
-  color: #888;
-}
-
-button {
-  border-radius: 8px;
-  border: 1px solid transparent;
-  padding: 0.6em 1.2em;
-  font-size: 1em;
-  font-weight: 500;
-  font-family: inherit;
-  background-color: #1a1a1a;
-  cursor: pointer;
-  transition: border-color 0.25s;
-}
-button:hover {
-  border-color: #646cff;
-}
-button:focus,
-button:focus-visible {
-  outline: 4px auto -webkit-focus-ring-color;
-}
-
-@media (prefers-color-scheme: light) {
-  :root {
-    color: #213547;
-    background-color: #ffffff;
-  }
-  a:hover {
-    color: #747bff;
-  }
-  button {
-    background-color: #f9f9f9;
-  }
-}

package/src/styling/LogStyleBuilder.ts

@@ -1,355 +0,0 @@
-/**
- * @fileoverview LogStyleBuilder for fluent log styling API
- */
-
-import type { Logger } from '../Logger.js';
-import type { LogStyles, LogLayout, SpacingType } from '../types/index.js';
-import { 
-    TimestampStyler, 
-    LevelStyler, 
-    PrefixStyler, 
-    MessageStyler, 
-    LocationStyler 
-} from './SemanticStyles.js';
-
-/**
- * Fluent API builder for log styling with semantic methods
- */
-export class LogStyleBuilder {
-    private logStyles: LogStyles = {};
-    private logger: Logger;
-
-    constructor(logger: Logger) {
-        this.logger = logger;
-    }
-
-    /**
-     * Configure timestamp styling
-     */
-    timestamp(): TimestampStyleBuilderProxy {
-        return new TimestampStyleBuilderProxy(this);
-    }
-
-    /**
-     * Configure level badge styling
-     */
-    level(): LevelStyleBuilderProxy {
-        return new LevelStyleBuilderProxy(this);
-    }
-
-    /**
-     * Configure prefix styling
-     */
-    prefix(): PrefixStyleBuilderProxy {
-        return new PrefixStyleBuilderProxy(this);
-    }
-
-    /**
-     * Configure message text styling
-     */
-    message(): MessageStyleBuilderProxy {
-        return new MessageStyleBuilderProxy(this);
-    }
-
-    /**
-     * Configure location info styling
-     */
-    location(): LocationStyleBuilderProxy {
-        return new LocationStyleBuilderProxy(this);
-    }
-
-    /**
-     * Use a predefined preset
-     */
-    usePreset(presetName: string): LogStyleBuilder {
-        // Will be implemented when we create the presets
-        console.warn(`Preset '${presetName}' will be available in next implementation phase`);
-        return this;
-    }
-
-    /**
-     * Customize with partial configuration
-     */
-    customize(overrides: Partial<LogStyles>): LogStyleBuilder {
-        this.logStyles = { ...this.logStyles, ...overrides };
-        return this;
-    }
-
-    /**
-     * Set layout spacing
-     */
-    spacing(type: SpacingType): LogStyleBuilder {
-        if (!this.logStyles.layout) {
-            this.logStyles.layout = { spacing: type };
-        } else {
-            this.logStyles.layout.spacing = type;
-        }
-
-        // Apply spacing-specific configurations
-        switch (type) {
-            case 'compact':
-                this.logStyles.layout.innerPadding = '1px';
-                this.logStyles.layout.outerMargin = '0px';
-                break;
-            case 'spacious':
-                this.logStyles.layout.innerPadding = '4px';
-                this.logStyles.layout.outerMargin = '2px';
-                break;
-            default: // normal
-                this.logStyles.layout.innerPadding = '2px';
-                this.logStyles.layout.outerMargin = '1px';
-        }
-        
-        return this;
-    }
-
-    /**
-     * Set backdrop filter for glassmorphism effects
-     */
-    backdrop(filter: string): LogStyleBuilder {
-        this.logStyles.backdrop = filter;
-        return this;
-    }
-
-    /**
-     * Set overall transparency
-     */
-    transparency(value: number): LogStyleBuilder {
-        this.logStyles.transparency = Math.max(0, Math.min(1, value));
-        return this;
-    }
-
-    /**
-     * Apply the configured styles to the logger
-     */
-    apply(): void {
-        // Store the configuration in the logger
-        // This will be implemented when we integrate with the main Logger
-        (this.logger as any)._customLogStyles = this.logStyles;
-        console.log('Applied log styles:', this.logStyles);
-    }
-
-    /**
-     * Get current configuration (for debugging)
-     */
-    getConfig(): LogStyles {
-        return { ...this.logStyles };
-    }
-
-    /**
-     * Internal method to update part configuration
-     */
-    _updatePartConfig(part: keyof LogStyles, styles: string): void {
-        if (part === 'layout' || part === 'backdrop' || part === 'transparency') {
-            return; // Skip these non-part configs
-        }
-        
-        if (!this.logStyles[part]) {
-            this.logStyles[part] = {};
-        }
-        
-        // Parse basic CSS styles into config
-        // This is a simplified approach - in production might want more sophisticated parsing
-        this.logStyles[part]!.style = styles;
-    }
-}
-
-/**
- * Base proxy class for part-specific styling
- */
-abstract class PartStyleBuilderProxy {
-    protected parentBuilder: LogStyleBuilder;
-    protected partName: keyof LogStyles;
-
-    constructor(parentBuilder: LogStyleBuilder, partName: keyof LogStyles) {
-        this.parentBuilder = parentBuilder;
-        this.partName = partName;
-    }
-
-    /**
-     * Return to the main builder for chaining other parts
-     */
-    and(): LogStyleBuilder {
-        return this.parentBuilder;
-    }
-
-    /**
-     * Apply styles and finish configuration
-     */
-    apply(): void {
-        this.parentBuilder.apply();
-    }
-
-    /**
-     * Helper to apply styles to the parent builder
-     */
-    protected applyStyles(styler: any): this {
-        const styles = styler.build();
-        this.parentBuilder._updatePartConfig(this.partName, styles);
-        return this;
-    }
-}
-
-/**
- * Timestamp styling proxy with fluent API
- */
-class TimestampStyleBuilderProxy extends PartStyleBuilderProxy {
-    constructor(parentBuilder: LogStyleBuilder) {
-        super(parentBuilder, 'timestamp');
-    }
-
-    default(): TimestampStyleBuilderProxy {
-        return this.applyStyles(new TimestampStyler().default());
-    }
-
-    hidden(): TimestampStyleBuilderProxy {
-        return this.applyStyles(new TimestampStyler().hidden());
-    }
-
-    minimal(): TimestampStyleBuilderProxy {
-        return this.applyStyles(new TimestampStyler().minimal());
-    }
-
-    muted(): TimestampStyleBuilderProxy {
-        return this.applyStyles(new TimestampStyler().muted());
-    }
-
-    mono(): TimestampStyleBuilderProxy {
-        return this.applyStyles(new TimestampStyler().mono());
-    }
-
-    compact(): TimestampStyleBuilderProxy {
-        return this.applyStyles(new TimestampStyler().compact());
-    }
-}
-
-/**
- * Level badge styling proxy with fluent API
- */
-class LevelStyleBuilderProxy extends PartStyleBuilderProxy {
-    constructor(parentBuilder: LogStyleBuilder) {
-        super(parentBuilder, 'level');
-    }
-
-    badge(): LevelStyleBuilderProxy {
-        return this.applyStyles(new LevelStyler().badge());
-    }
-
-    gradient(from?: string, to?: string): LevelStyleBuilderProxy {
-        return this.applyStyles(new LevelStyler().gradient(from, to));
-    }
-
-    glowing(): LevelStyleBuilderProxy {
-        return this.applyStyles(new LevelStyler().glowing());
-    }
-
-    flat(): LevelStyleBuilderProxy {
-        return this.applyStyles(new LevelStyler().flat());
-    }
-
-    bold(): LevelStyleBuilderProxy {
-        return this.applyStyles(new LevelStyler().bold());
-    }
-
-    uppercase(): LevelStyleBuilderProxy {
-        return this.applyStyles(new LevelStyler().uppercase());
-    }
-
-    neon(): LevelStyleBuilderProxy {
-        return this.applyStyles(new LevelStyler().neon());
-    }
-}
-
-/**
- * Prefix styling proxy with fluent API
- */
-class PrefixStyleBuilderProxy extends PartStyleBuilderProxy {
-    constructor(parentBuilder: LogStyleBuilder) {
-        super(parentBuilder, 'prefix');
-    }
-
-    dark(): PrefixStyleBuilderProxy {
-        return this.applyStyles(new PrefixStyler().dark());
-    }
-
-    light(): PrefixStyleBuilderProxy {
-        return this.applyStyles(new PrefixStyler().light());
-    }
-
-    compact(): PrefixStyleBuilderProxy {
-        return this.applyStyles(new PrefixStyler().compact());
-    }
-
-    muted(): PrefixStyleBuilderProxy {
-        return this.applyStyles(new PrefixStyler().muted());
-    }
-
-    mono(): PrefixStyleBuilderProxy {
-        return this.applyStyles(new PrefixStyler().mono());
-    }
-}
-
-/**
- * Message styling proxy with fluent API
- */
-class MessageStyleBuilderProxy extends PartStyleBuilderProxy {
-    constructor(parentBuilder: LogStyleBuilder) {
-        super(parentBuilder, 'message');
-    }
-
-    readable(): MessageStyleBuilderProxy {
-        return this.applyStyles(new MessageStyler().readable());
-    }
-
-    code(): MessageStyleBuilderProxy {
-        return this.applyStyles(new MessageStyler().code());
-    }
-
-    large(): MessageStyleBuilderProxy {
-        return this.applyStyles(new MessageStyler().large());
-    }
-
-    system(): MessageStyleBuilderProxy {
-        return this.applyStyles(new MessageStyler().system());
-    }
-
-    mono(): MessageStyleBuilderProxy {
-        return this.applyStyles(new MessageStyler().mono());
-    }
-}
-
-/**
- * Location styling proxy with fluent API
- */
-class LocationStyleBuilderProxy extends PartStyleBuilderProxy {
-    constructor(parentBuilder: LogStyleBuilder) {
-        super(parentBuilder, 'location');
-    }
-
-    subtle(): LocationStyleBuilderProxy {
-        return this.applyStyles(new LocationStyler().subtle());
-    }
-
-    hidden(): LocationStyleBuilderProxy {
-        return this.applyStyles(new LocationStyler().hidden());
-    }
-
-    clickable(): LocationStyleBuilderProxy {
-        return this.applyStyles(new LocationStyler().clickable());
-    }
-
-    muted(): LocationStyleBuilderProxy {
-        return this.applyStyles(new LocationStyler().muted());
-    }
-
-    mono(): LocationStyleBuilderProxy {
-        return this.applyStyles(new LocationStyler().mono());
-    }
-}
-
-/**
- * Create a new LogStyleBuilder instance
- */
-export function createLogStyleBuilder(logger: Logger): LogStyleBuilder {
-    return new LogStyleBuilder(logger);
-}