@mks2508/better-logger 0.0.2-alpha.2 → 0.3.0

package/dist/utils/environment.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Environment detection utilities for Universal Logger
+ */
+/**
+ * Checks if running in Node.js environment
+ */
+export declare const isNode: string | false;
+/**
+ * Checks if running in browser environment
+ */
+export declare const isBrowser: boolean;
+/**
+ * Checks if running in web worker environment
+ */
+export declare const isWebWorker: boolean;
+/**
+ * Checks if running in Deno environment
+ */
+export declare const isDeno: boolean;
+/**
+ * Gets the current runtime environment
+ */
+export declare function getRuntimeEnvironment(): 'node' | 'browser' | 'webworker' | 'deno' | 'unknown';
+/**
+ * Checks if colors/styling should be supported in current environment
+ */
+export declare function supportsColors(): boolean;
+/**
+ * Checks if CSS styling is supported (browser-only feature)
+ */
+export declare function supportsCSSColors(): boolean;
+/**
+ * Checks if ANSI colors are supported (terminal environments)
+ */
+export declare function supportsANSIColors(): boolean;
+/**
+ * Gets environment-specific information
+ */
+export declare function getEnvironmentInfo(): {
+    runtime: "unknown" | "node" | "browser" | "webworker" | "deno";
+    supportsColors: boolean;
+    supportsCSSColors: boolean;
+    supportsANSIColors: boolean;
+    isProduction: boolean;
+    version: string;
+};
+//# sourceMappingURL=environment.d.ts.map

package/dist/utils/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/utils/environment.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,eAAO,MAAM,MAAM,gBAEwB,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,SAAS,SACmC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,WAAW,SACqD,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,MAAM,SACuB,CAAC;AAE3C;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,GAAG,SAAS,CAM7F;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAcxC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAQ5C;AAED;;GAEG;AACH,wBAAgB,kBAAkB;;;;;;;EAWjC"}

package/dist/utils/environment.js

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview Environment detection utilities for Universal Logger
+ */
+/**
+ * Checks if running in Node.js environment
+ */
+export const isNode = typeof process !== 'undefined' &&
+    process.versions &&
+    process.versions.node;
+/**
+ * Checks if running in browser environment
+ */
+export const isBrowser = typeof window !== 'undefined' &&
+    typeof document !== 'undefined';
+/**
+ * Checks if running in web worker environment
+ */
+export const isWebWorker = typeof self !== 'undefined' &&
+    typeof self.importScripts === 'function';
+/**
+ * Checks if running in Deno environment
+ */
+export const isDeno = typeof globalThis !== 'undefined' &&
+    'Deno' in globalThis;
+/**
+ * Gets the current runtime environment
+ */
+export function getRuntimeEnvironment() {
+    if (isNode)
+        return 'node';
+    if (isBrowser)
+        return 'browser';
+    if (isWebWorker)
+        return 'webworker';
+    if (isDeno)
+        return 'deno';
+    return 'unknown';
+}
+/**
+ * Checks if colors/styling should be supported in current environment
+ */
+export function supportsColors() {
+    if (isBrowser) {
+        // Browser always supports CSS colors
+        return true;
+    }
+    if (isNode) {
+        // Check if Node.js supports colors
+        return process.stdout?.isTTY === true ||
+            process.env.FORCE_COLOR === '1' ||
+            process.env.FORCE_COLOR === 'true';
+    }
+    return false;
+}
+/**
+ * Checks if CSS styling is supported (browser-only feature)
+ */
+export function supportsCSSColors() {
+    return isBrowser;
+}
+/**
+ * Checks if ANSI colors are supported (terminal environments)
+ */
+export function supportsANSIColors() {
+    if (isNode) {
+        return process.stdout?.isTTY === true ||
+            process.env.FORCE_COLOR === '1' ||
+            process.env.FORCE_COLOR === 'true';
+    }
+    return false;
+}
+/**
+ * Gets environment-specific information
+ */
+export function getEnvironmentInfo() {
+    const env = getRuntimeEnvironment();
+    return {
+        runtime: env,
+        supportsColors: supportsColors(),
+        supportsCSSColors: supportsCSSColors(),
+        supportsANSIColors: supportsANSIColors(),
+        isProduction: isNode ? process.env.NODE_ENV === 'production' : false,
+        version: isNode ? process.versions.node : (isBrowser ? navigator.userAgent : 'unknown')
+    };
+}

package/dist/utils/formatting.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Formatting utilities for Universal Logger
+ */
+import type { LogLevel, StackInfo } from '../types/index.js';
+/**
+ * Creates plain text output for any environment
+ * No colors, no styling - maximum compatibility
+ */
+export declare function createPlainOutput(level: LogLevel, message: string, prefix?: string, stackInfo?: StackInfo | null): string;
+/**
+ * Gets the appropriate log method for the level
+ * Uses different console methods for better semantics
+ */
+export declare function getConsoleMethod(level: LogLevel): 'log' | 'info' | 'warn' | 'error';
+/**
+ * Create a simple log entry object for handlers
+ */
+export declare function createLogEntry(level: LogLevel, message: string, args: any[], prefix?: string, stackInfo?: StackInfo | null): {
+    timestamp: string;
+    level: string;
+    prefix: string | undefined;
+    message: string;
+    args: any[];
+    location: {
+        file: string;
+        line: number;
+        column: number;
+        function: string | undefined;
+    } | undefined;
+    raw: any[];
+};
+/**
+ * Format data for table display in plain text
+ */
+export declare function formatTablePlain(data: any, columns?: string[]): string;
+/**
+ * Safe object serialization for logging
+ */
+export declare function safeSerialize(obj: any, maxDepth?: number, currentDepth?: number): any;
+//# sourceMappingURL=formatting.d.ts.map

package/dist/utils/formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../src/utils/formatting.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAG7D;;;GAGG;AACH,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAC7B,MAAM,CAiBR;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAcnF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,GAAG,EAAE,EACX,MAAM,CAAC,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI;;;;;;;;;;;;;EAgB/B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CA+BtE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAE,MAAU,EAAE,YAAY,GAAE,MAAU,GAAG,GAAG,CAqB3F"}

package/dist/utils/formatting.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Formatting utilities for Universal Logger
+ */
+import { formatTimestamp } from './timestamps.js';
+/**
+ * Creates plain text output for any environment
+ * No colors, no styling - maximum compatibility
+ */
+export function createPlainOutput(level, message, prefix, stackInfo) {
+    const timestamp = formatTimestamp();
+    const timeStr = timestamp.slice(11, 23); // HH:MM:SS.mmm
+    let output = `[${timeStr}] [${level.toUpperCase()}]`;
+    if (prefix) {
+        output += ` [${prefix}]`;
+    }
+    output += ` ${message}`;
+    if (stackInfo) {
+        output += ` (${stackInfo.file}:${stackInfo.line}:${stackInfo.column})`;
+    }
+    return output;
+}
+/**
+ * Gets the appropriate log method for the level
+ * Uses different console methods for better semantics
+ */
+export function getConsoleMethod(level) {
+    switch (level) {
+        case 'debug':
+            return 'log';
+        case 'info':
+            return 'info';
+        case 'warn':
+            return 'warn';
+        case 'error':
+        case 'critical':
+            return 'error';
+        default:
+            return 'log';
+    }
+}
+/**
+ * Create a simple log entry object for handlers
+ */
+export function createLogEntry(level, message, args, prefix, stackInfo) {
+    return {
+        timestamp: formatTimestamp(),
+        level: level.toUpperCase(),
+        prefix,
+        message,
+        args: args.slice(1), // Exclude the first message argument
+        location: stackInfo ? {
+            file: stackInfo.file,
+            line: stackInfo.line,
+            column: stackInfo.column,
+            function: stackInfo.function
+        } : undefined,
+        raw: args
+    };
+}
+/**
+ * Format data for table display in plain text
+ */
+export function formatTablePlain(data, columns) {
+    try {
+        if (Array.isArray(data)) {
+            if (data.length === 0)
+                return '[Empty Array]';
+            // Simple array formatting
+            if (typeof data[0] !== 'object') {
+                return data.map((item, i) => `${i}: ${item}`).join('\n');
+            }
+            // Object array formatting
+            const keys = columns || Object.keys(data[0] || {});
+            const header = keys.join('\t');
+            const rows = data.map(item => keys.map(key => String(item[key] || '')).join('\t'));
+            return [header, ...rows].join('\n');
+        }
+        if (typeof data === 'object' && data !== null) {
+            // Simple object formatting
+            return Object.entries(data)
+                .map(([key, value]) => `${key}: ${value}`)
+                .join('\n');
+        }
+        return String(data);
+    }
+    catch (error) {
+        return `[Error formatting table: ${error}]`;
+    }
+}
+/**
+ * Safe object serialization for logging
+ */
+export function safeSerialize(obj, maxDepth = 3, currentDepth = 0) {
+    if (currentDepth >= maxDepth) {
+        return '[Max Depth Reached]';
+    }
+    if (obj === null)
+        return null;
+    if (obj === undefined)
+        return '[undefined]';
+    if (typeof obj === 'function')
+        return '[Function]';
+    if (obj instanceof Error)
+        return `[Error: ${obj.message}]`;
+    if (obj instanceof Date)
+        return obj.toISOString();
+    if (typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map(item => safeSerialize(item, maxDepth, currentDepth + 1));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[key] = safeSerialize(value, maxDepth, currentDepth + 1);
+    }
+    return result;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Utility functions exports for Advanced Logger
+ */
+export { parseStackTrace } from './stackTrace.js';
+export { formatTimestamp, parseRelativeTime, parseTimeInput, formatDisplayTime } from './timestamps.js';
+export { createStyledOutput, generateLogId, escapeHtml, safeStringify, detectDevToolsTheme, getAdaptiveColor, setupThemeChangeListener, type LevelStyleConfig } from './output.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EACH,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACH,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,EACxB,KAAK,gBAAgB,EACxB,MAAM,aAAa,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Utility functions exports for Advanced Logger
+ */
+export { parseStackTrace } from './stackTrace.js';
+export { formatTimestamp, parseRelativeTime, parseTimeInput, formatDisplayTime } from './timestamps.js';
+export { createStyledOutput, generateLogId, escapeHtml, safeStringify, detectDevToolsTheme, getAdaptiveColor, setupThemeChangeListener } from './output.js';

package/dist/utils/opentui-detection.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview OpenTUI detection and enhancement utilities for core logger
+ */
+/**
+ * Check if OpenTUI packages are available
+ */
+export declare function hasOpenTUI(): Promise<boolean>;
+/**
+ * Check if OpenTUI enhancement package is available
+ */
+export declare function hasOpenTUILogHandler(): Promise<boolean>;
+/**
+ * Dynamically enhance logger with OpenTUI if available
+ */
+export declare function tryEnhanceWithOpenTUI(logger: any): Promise<boolean>;
+/**
+ * Get OpenTUI environment information
+ */
+export declare function getOpenTUIInfo(): Promise<{
+    available: boolean;
+    coreAvailable: boolean;
+    handlerAvailable: boolean;
+    nodeVersion: string | null;
+    terminalSupport: boolean;
+}>;
+/**
+ * Auto-enhance logger with best available rendering
+ */
+export declare function autoEnhanceLogger(logger: any): Promise<{
+    enhanced: boolean;
+    method: 'opentui' | 'ansi' | 'plain';
+    info?: any;
+}>;
+//# sourceMappingURL=opentui-detection.d.ts.map

package/dist/utils/opentui-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentui-detection.d.ts","sourceRoot":"","sources":["../../src/utils/opentui-detection.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC,CAanD;AAED;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAY7D;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAkCzE;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC;IAC5C,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC5B,CAAC,CAaD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC;IAC1D,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;IACrC,IAAI,CAAC,EAAE,GAAG,CAAC;CACd,CAAC,CA0BD"}

package/dist/utils/opentui-detection.js

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview OpenTUI detection and enhancement utilities for core logger
+ */
+import { isNode } from './environment.js';
+/**
+ * Check if OpenTUI packages are available
+ */
+export async function hasOpenTUI() {
+    if (!isNode) {
+        return false; // OpenTUI is Node.js only
+    }
+    try {
+        // Try to dynamically import OpenTUI core
+        // @ts-expect-error - Optional dependency, may not be installed
+        await import('@opentui/core');
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Check if OpenTUI enhancement package is available
+ */
+export async function hasOpenTUILogHandler() {
+    if (!isNode) {
+        return false;
+    }
+    try {
+        // @ts-expect-error - Optional dependency, may not be installed
+        await import('@mks2508/better-logger-nodejs-opentui');
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Dynamically enhance logger with OpenTUI if available
+ */
+export async function tryEnhanceWithOpenTUI(logger) {
+    try {
+        // Check if both OpenTUI and our enhancement package are available
+        const [hasCore, hasEnhancer] = await Promise.all([
+            hasOpenTUI(),
+            hasOpenTUILogHandler()
+        ]);
+        if (!hasCore || !hasEnhancer) {
+            return false;
+        }
+        // Dynamically import and apply enhancement
+        // @ts-expect-error - Optional dependency, may not be installed
+        const { enhanceLoggerWithOpenTUI } = await import('@mks2508/better-logger-nodejs-opentui');
+        const enhanced = await enhanceLoggerWithOpenTUI(logger, {
+            renderer: {
+                animated: true,
+                theme: 'auto',
+                components: {
+                    badges: true,
+                    progressBars: false,
+                    tables: false,
+                    charts: false
+                }
+            }
+        });
+        return enhanced;
+    }
+    catch (error) {
+        console.warn('Failed to enhance logger with OpenTUI:', error);
+        return false;
+    }
+}
+/**
+ * Get OpenTUI environment information
+ */
+export async function getOpenTUIInfo() {
+    const [coreAvailable, handlerAvailable] = await Promise.all([
+        hasOpenTUI(),
+        hasOpenTUILogHandler()
+    ]);
+    return {
+        available: coreAvailable && handlerAvailable,
+        coreAvailable,
+        handlerAvailable,
+        nodeVersion: isNode ? process.version : null,
+        terminalSupport: isNode ? process.stdout?.isTTY === true : false
+    };
+}
+/**
+ * Auto-enhance logger with best available rendering
+ */
+export async function autoEnhanceLogger(logger) {
+    // Try OpenTUI first
+    const openTUIEnhanced = await tryEnhanceWithOpenTUI(logger);
+    if (openTUIEnhanced) {
+        return {
+            enhanced: true,
+            method: 'opentui',
+            info: await getOpenTUIInfo()
+        };
+    }
+    // Fallback to ANSI colors if in Node.js
+    if (isNode && process.stdout?.isTTY) {
+        return {
+            enhanced: false,
+            method: 'ansi',
+            info: { reason: 'OpenTUI not available, using ANSI colors' }
+        };
+    }
+    // Plain text fallback
+    return {
+        enhanced: false,
+        method: 'plain',
+        info: { reason: 'No enhanced rendering available' }
+    };
+}

package/dist/utils/output.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Styled output creation utilities for Advanced Logger
+ */
+import type { LogLevel, StackInfo, DevToolsTheme, AdaptiveColors } from '../types/index.js';
+/**
+ * Style configuration for each log level
+ */
+export interface LevelStyleConfig {
+    emoji: string;
+    label: string;
+    background: string;
+    color: string;
+    border: string;
+    shadow: string;
+}
+/**
+ * Detects the current DevTools theme preference
+ */
+export declare function detectDevToolsTheme(): DevToolsTheme;
+/**
+ * Gets adaptive color based on current DevTools theme
+ */
+export declare function getAdaptiveColor(colors: AdaptiveColors, theme?: DevToolsTheme): string;
+/**
+ * Sets up theme change listener for dynamic updates
+ */
+export declare function setupThemeChangeListener(callback: (theme: DevToolsTheme) => void): (() => void) | null;
+/**
+ * Creates styled console output with multiple %c formatters
+ */
+export declare function createStyledOutput(level: LogLevel, levelStyles: Record<LogLevel | 'success', LevelStyleConfig>, prefix: string | undefined, message: string, stackInfo: StackInfo | null, autoDetectTheme?: boolean): [string, ...string[]];
+/**
+ * Create a unique ID for log entries
+ */
+export declare function generateLogId(): string;
+/**
+ * Escape HTML entities for safe HTML output
+ */
+export declare function escapeHtml(text: string): string;
+/**
+ * Convert objects to safe string representation for logging
+ */
+export declare function safeStringify(obj: any, _maxDepth?: number): string;
+//# sourceMappingURL=output.d.ts.map

package/dist/utils/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/utils/output.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAK5F;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAYnD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,MAAM,CAGtF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAyBtG;AAGD;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,QAAQ,EACf,WAAW,EAAE,MAAM,CAAC,QAAQ,GAAG,SAAS,EAAE,gBAAgB,CAAC,EAC3D,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,GAAG,IAAI,EAC3B,eAAe,GAAE,OAAc,GAChC,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAgEvB;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,SAAI,GAAG,MAAM,CAY7D"}

package/dist/utils/output.js

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Styled output creation utilities for Advanced Logger
+ */
+import { formatTimestamp } from './timestamps.js';
+import { StyleBuilder } from '../styling/index.js';
+import { ADAPTIVE_COLORS } from '../constants.js';
+/**
+ * Detects the current DevTools theme preference
+ */
+export function detectDevToolsTheme() {
+    try {
+        if (typeof window === 'undefined' || !window.matchMedia) {
+            return 'light'; // Safe fallback for SSR or older browsers
+        }
+        const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        return mediaQuery.matches ? 'dark' : 'light';
+    }
+    catch (error) {
+        console.warn('Failed to detect DevTools theme:', error);
+        return 'light'; // Fallback to light theme
+    }
+}
+/**
+ * Gets adaptive color based on current DevTools theme
+ */
+export function getAdaptiveColor(colors, theme) {
+    const currentTheme = theme ?? detectDevToolsTheme();
+    return colors[currentTheme];
+}
+/**
+ * Sets up theme change listener for dynamic updates
+ */
+export function setupThemeChangeListener(callback) {
+    try {
+        if (typeof window === 'undefined' || !window.matchMedia) {
+            return null;
+        }
+        const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        const handler = (e) => {
+            callback(e.matches ? 'dark' : 'light');
+        };
+        // Use newer addEventListener if available, fallback to addListener
+        if (mediaQuery.addEventListener) {
+            mediaQuery.addEventListener('change', handler);
+            return () => mediaQuery.removeEventListener('change', handler);
+        }
+        else if (mediaQuery.addListener) {
+            mediaQuery.addListener(handler);
+            return () => mediaQuery.removeListener?.(handler);
+        }
+        return null;
+    }
+    catch (error) {
+        console.warn('Failed to set up theme change listener:', error);
+        return null;
+    }
+}
+/**
+ * Creates styled console output with multiple %c formatters
+ */
+export function createStyledOutput(level, levelStyles, prefix, message, stackInfo, autoDetectTheme = true) {
+    const levelConfig = levelStyles[level];
+    const timestamp = formatTimestamp();
+    const currentTheme = autoDetectTheme ? detectDevToolsTheme() : 'light';
+    // Base styles with adaptive colors
+    const timestampStyle = new StyleBuilder()
+        .color(getAdaptiveColor(ADAPTIVE_COLORS.timestamp, currentTheme))
+        .size('11px')
+        .font('Monaco, Consolas, monospace')
+        .build();
+    const levelStyle = new StyleBuilder()
+        .bg(levelConfig.background)
+        .color(levelConfig.color)
+        .border(levelConfig.border)
+        .shadow(levelConfig.shadow)
+        .padding('2px 8px')
+        .rounded('4px')
+        .bold()
+        .font('Monaco, Consolas, monospace')
+        .size('12px')
+        .build();
+    const prefixStyle = new StyleBuilder()
+        .bg(getAdaptiveColor(ADAPTIVE_COLORS.prefixBackground, currentTheme))
+        .color(getAdaptiveColor(ADAPTIVE_COLORS.prefix, currentTheme))
+        .padding('2px 6px')
+        .rounded('3px')
+        .bold()
+        .font('Monaco, Consolas, monospace')
+        .size('11px')
+        .build();
+    const messageStyle = new StyleBuilder()
+        .color(getAdaptiveColor(ADAPTIVE_COLORS.messageText, currentTheme))
+        .font('system-ui, -apple-system, sans-serif')
+        .size('14px')
+        .build();
+    const locationStyle = new StyleBuilder()
+        .color(getAdaptiveColor(ADAPTIVE_COLORS.location, currentTheme))
+        .size('11px')
+        .font('Monaco, Consolas, monospace')
+        .build();
+    // Build format string and styles
+    let format = `%c${timestamp.slice(11, 23)} %c${levelConfig.emoji} ${levelConfig.label}`;
+    const styles = [timestampStyle, levelStyle];
+    if (prefix) {
+        format += ` %c${prefix}`;
+        styles.push(prefixStyle);
+    }
+    format += ` %c${message}`;
+    styles.push(messageStyle);
+    if (stackInfo) {
+        format += ` %c(${stackInfo.file}:${stackInfo.line}:${stackInfo.column})`;
+        styles.push(locationStyle);
+    }
+    return [format, ...styles];
+}
+/**
+ * Create a unique ID for log entries
+ */
+export function generateLogId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Escape HTML entities for safe HTML output
+ */
+export function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+/**
+ * Convert objects to safe string representation for logging
+ */
+export function safeStringify(obj, _maxDepth = 3) {
+    try {
+        return JSON.stringify(obj, (_key, value) => {
+            if (typeof value === 'function')
+                return '[Function]';
+            if (value instanceof Error)
+                return `[Error: ${value.message}]`;
+            if (value instanceof Date)
+                return value.toISOString();
+            if (typeof value === 'undefined')
+                return '[undefined]';
+            return value;
+        }, 2);
+    }
+    catch (error) {
+        return String(obj);
+    }
+}

package/dist/utils/stackTrace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Stack trace parsing utilities for Advanced Logger
+ */
+import type { StackInfo } from '../types/index.js';
+/**
+ * Parses the current stack trace to extract caller information
+ */
+export declare function parseStackTrace(): StackInfo | null;
+//# sourceMappingURL=stackTrace.d.ts.map