@nice2dev/game-engine 1.0.5 → 1.0.10

package/dist/esm/editor/ConsolePro.js

@@ -0,0 +1,1085 @@
+/**
+ * @file ConsolePro.ts
+ * @description Advanced Console System with filtering and object inspection
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Log levels (info, warn, error, debug, verbose, custom)
+ * - Stack trace capture
+ * - Object inspection/serialization
+ * - Filtering by level, tag, regex
+ * - Search within logs
+ * - Log groups (collapsible)
+ * - Console commands with auto-complete
+ * - Expression evaluation
+ * - Watch expressions
+ * - Export logs
+ * - Log persistence
+ */
+const DEFAULT_CONSOLE_CONFIG = {
+    maxEntries: 10000,
+    showTimestamps: true,
+    showSource: true,
+    captureStackTrace: true,
+    stackTraceDepth: 10,
+    collapseRepeated: true,
+    preserveLog: false,
+    autoScroll: true,
+    wordWrap: true,
+    showIcons: true,
+    timestampFormat: 'absolute',
+    defaultLevelFilter: ['verbose', 'debug', 'info', 'warn', 'error', 'assert'],
+    defaultTagFilter: [],
+    enableCommands: true,
+    commandPrefix: '/',
+};
+// ============================================================
+// Value Inspection
+// ============================================================
+function inspectValue(value, depth = 0, maxDepth = 3) {
+    if (value === null) {
+        return { type: 'null', preview: 'null', expandable: false };
+    }
+    if (value === undefined) {
+        return { type: 'undefined', preview: 'undefined', expandable: false };
+    }
+    const typeOf = typeof value;
+    switch (typeOf) {
+        case 'string':
+            return {
+                type: 'string',
+                preview: `"${truncate(value, 100)}"`,
+                value,
+                expandable: value.length > 100,
+            };
+        case 'number':
+            return {
+                type: 'number',
+                preview: String(value),
+                value,
+                expandable: false,
+            };
+        case 'boolean':
+            return {
+                type: 'boolean',
+                preview: String(value),
+                value,
+                expandable: false,
+            };
+        case 'bigint':
+            return {
+                type: 'bigint',
+                preview: `${value}n`,
+                value,
+                expandable: false,
+            };
+        case 'symbol':
+            return {
+                type: 'symbol',
+                preview: value.toString(),
+                expandable: false,
+            };
+        case 'function':
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            const fn = value;
+            return {
+                type: 'function',
+                preview: `ƒ ${fn.name || 'anonymous'}()`,
+                expandable: true,
+                className: 'Function',
+                children: depth < maxDepth ? inspectFunctionProperties(fn, depth, maxDepth) : undefined,
+            };
+        case 'object':
+            return inspectObject(value, depth, maxDepth);
+    }
+    return { type: 'undefined', preview: 'unknown', expandable: false };
+}
+function inspectObject(obj, depth, maxDepth) {
+    // Check for special types
+    if (obj instanceof Date) {
+        return {
+            type: 'date',
+            preview: obj.toISOString(),
+            value: obj,
+            expandable: true,
+            className: 'Date',
+            children: depth < maxDepth ? inspectObjectProperties(obj, depth, maxDepth) : undefined,
+        };
+    }
+    if (obj instanceof RegExp) {
+        return {
+            type: 'regexp',
+            preview: obj.toString(),
+            value: obj,
+            expandable: true,
+            className: 'RegExp',
+            children: depth < maxDepth ? inspectObjectProperties(obj, depth, maxDepth) : undefined,
+        };
+    }
+    if (obj instanceof Error) {
+        return {
+            type: 'error',
+            preview: `${obj.name}: ${obj.message}`,
+            value: obj,
+            expandable: true,
+            className: obj.constructor.name,
+            children: depth < maxDepth
+                ? [
+                    {
+                        name: 'message',
+                        value: inspectValue(obj.message, depth + 1, maxDepth),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        isGetter: false,
+                        isSetter: false,
+                    },
+                    {
+                        name: 'stack',
+                        value: inspectValue(obj.stack, depth + 1, maxDepth),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                        isGetter: false,
+                        isSetter: false,
+                    },
+                ]
+                : undefined,
+        };
+    }
+    if (obj instanceof Map) {
+        const entries = Array.from(obj.entries()).slice(0, 10);
+        return {
+            type: 'map',
+            preview: `Map(${obj.size})`,
+            expandable: obj.size > 0,
+            className: 'Map',
+            children: depth < maxDepth
+                ? entries.map(([key, val], i) => ({
+                    name: String(key),
+                    value: inspectValue(val, depth + 1, maxDepth),
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    isGetter: false,
+                    isSetter: false,
+                }))
+                : undefined,
+        };
+    }
+    if (obj instanceof Set) {
+        const values = Array.from(obj).slice(0, 10);
+        return {
+            type: 'set',
+            preview: `Set(${obj.size})`,
+            expandable: obj.size > 0,
+            className: 'Set',
+            children: depth < maxDepth
+                ? values.map((val, i) => ({
+                    name: String(i),
+                    value: inspectValue(val, depth + 1, maxDepth),
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    isGetter: false,
+                    isSetter: false,
+                }))
+                : undefined,
+        };
+    }
+    if (obj instanceof Promise) {
+        return {
+            type: 'promise',
+            preview: 'Promise {<pending>}',
+            expandable: false,
+            className: 'Promise',
+        };
+    }
+    // Check for DOM elements
+    if (typeof HTMLElement !== 'undefined' && obj instanceof HTMLElement) {
+        return {
+            type: 'dom',
+            preview: `<${obj.tagName.toLowerCase()}${obj.id ? `#${obj.id}` : ''}${obj.className ? `.${obj.className.split(' ').join('.')}` : ''}>`,
+            expandable: true,
+            className: obj.constructor.name,
+            children: depth < maxDepth ? inspectObjectProperties(obj, depth, maxDepth, 20) : undefined,
+        };
+    }
+    // Array
+    if (Array.isArray(obj)) {
+        const preview = obj.length <= 5
+            ? `[${obj.map((v) => (typeof v === 'string' ? `"${truncate(v, 20)}"` : truncate(String(v), 20))).join(', ')}]`
+            : `Array(${obj.length})`;
+        return {
+            type: 'array',
+            preview,
+            expandable: obj.length > 0,
+            className: 'Array',
+            children: depth < maxDepth
+                ? obj.slice(0, 100).map((val, i) => ({
+                    name: String(i),
+                    value: inspectValue(val, depth + 1, maxDepth),
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    isGetter: false,
+                    isSetter: false,
+                }))
+                : undefined,
+        };
+    }
+    // Plain object
+    const keys = Object.keys(obj);
+    const preview = keys.length <= 3
+        ? `{${keys
+            .slice(0, 3)
+            .map((k) => `${k}: ${truncate(String(obj[k]), 20)}`)
+            .join(', ')}}`
+        : `{${keys
+            .slice(0, 2)
+            .map((k) => k)
+            .join(', ')}...}`;
+    return {
+        type: 'object',
+        preview,
+        expandable: keys.length > 0,
+        className: obj.constructor.name !== 'Object' ? obj.constructor.name : undefined,
+        children: depth < maxDepth ? inspectObjectProperties(obj, depth, maxDepth) : undefined,
+    };
+}
+function inspectObjectProperties(obj, depth, maxDepth, limit = 100) {
+    const properties = [];
+    const seen = new Set();
+    // Own enumerable properties
+    for (const key of Object.keys(obj).slice(0, limit)) {
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+        properties.push({
+            name: key,
+            value: descriptor?.get
+                ? { type: 'function', preview: '(...)', expandable: false }
+                : inspectValue(obj[key], depth + 1, maxDepth),
+            enumerable: descriptor?.enumerable ?? true,
+            configurable: descriptor?.configurable ?? true,
+            writable: descriptor?.writable ?? true,
+            isGetter: !!descriptor?.get,
+            isSetter: !!descriptor?.set,
+        });
+    }
+    return properties;
+}
+function inspectFunctionProperties(
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+fn, depth, maxDepth) {
+    return [
+        {
+            name: 'name',
+            value: inspectValue(fn.name, depth + 1, maxDepth),
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            isGetter: false,
+            isSetter: false,
+        },
+        {
+            name: 'length',
+            value: inspectValue(fn.length, depth + 1, maxDepth),
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            isGetter: false,
+            isSetter: false,
+        },
+    ];
+}
+function truncate(str, maxLength) {
+    return str.length > maxLength ? str.substring(0, maxLength) + '...' : str;
+}
+// ============================================================
+// Stack Trace Parsing
+// ============================================================
+function captureStackTrace(depth = 10) {
+    const error = new Error();
+    const stack = error.stack || '';
+    const lines = stack.split('\n').slice(3); // Skip Error, captureStackTrace, and caller
+    const frames = [];
+    for (const line of lines.slice(0, depth)) {
+        const frame = parseStackLine(line);
+        if (frame) {
+            frames.push(frame);
+        }
+    }
+    return frames;
+}
+function parseStackLine(line) {
+    // Chrome/Node format: "    at functionName (file:line:column)"
+    const chromeMatch = line.match(/^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+    if (chromeMatch) {
+        return {
+            functionName: chromeMatch[1] || '<anonymous>',
+            fileName: chromeMatch[2],
+            lineNumber: parseInt(chromeMatch[3], 10),
+            columnNumber: parseInt(chromeMatch[4], 10),
+            source: line.trim(),
+        };
+    }
+    // Firefox format: "functionName@file:line:column"
+    const firefoxMatch = line.match(/^(.*)@(.+?):(\d+):(\d+)$/);
+    if (firefoxMatch) {
+        return {
+            functionName: firefoxMatch[1] || '<anonymous>',
+            fileName: firefoxMatch[2],
+            lineNumber: parseInt(firefoxMatch[3], 10),
+            columnNumber: parseInt(firefoxMatch[4], 10),
+            source: line.trim(),
+        };
+    }
+    return null;
+}
+// ============================================================
+// Console Pro Class
+// ============================================================
+class ConsolePro {
+    constructor(config) {
+        this.config = { ...DEFAULT_CONSOLE_CONFIG };
+        this.entries = [];
+        this.groups = new Map();
+        this.currentGroupId = null;
+        this.groupStack = [];
+        this.commands = new Map();
+        this.watchExpressions = [];
+        this.lastEntryHash = '';
+        this.searchFilter = '';
+        this.regexFilter = null;
+        // Context for expression evaluation
+        this.evalContext = {};
+        // ─── Timing ────────────────────────────────────────────
+        this.timers = new Map();
+        // ─── Counting ──────────────────────────────────────────
+        this.counters = new Map();
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+        this.levelFilter = new Set(this.config.defaultLevelFilter);
+        this.tagFilter = new Set(this.config.defaultTagFilter);
+        // Register built-in commands
+        this.registerBuiltInCommands();
+    }
+    // ─── Configuration ─────────────────────────────────────
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+        this.onChange?.();
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    // ─── Logging Methods ───────────────────────────────────
+    log(...args) {
+        this.addEntry('info', 'info', args);
+    }
+    info(...args) {
+        this.addEntry('info', 'info', args);
+    }
+    warn(...args) {
+        this.addEntry('warn', 'warn', args);
+    }
+    error(...args) {
+        this.addEntry('error', 'error', args);
+    }
+    debug(...args) {
+        this.addEntry('debug', 'debug', args);
+    }
+    verbose(...args) {
+        this.addEntry('verbose', 'none', args);
+    }
+    assert(condition, ...args) {
+        if (!condition) {
+            this.addEntry('assert', 'failure', ['Assertion failed:', ...args]);
+        }
+    }
+    success(...args) {
+        this.addEntry('custom', 'success', args);
+    }
+    network(...args) {
+        this.addEntry('custom', 'network', args);
+    }
+    system(...args) {
+        this.addEntry('custom', 'system', args);
+    }
+    /**
+     * Log with tags for filtering
+     */
+    tagged(tags, ...args) {
+        this.addEntry('info', 'info', args, tags);
+    }
+    // ─── Grouping ──────────────────────────────────────────
+    group(label) {
+        const groupId = `group_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const depth = this.groupStack.length;
+        const group = {
+            id: groupId,
+            label,
+            collapsed: false,
+            entries: [],
+            parent: this.currentGroupId ?? undefined,
+            depth,
+        };
+        this.groups.set(groupId, group);
+        // Create group start entry
+        const entry = this.createEntry('info', 'none', [label]);
+        entry.isGroupStart = true;
+        entry.groupId = groupId;
+        this.pushEntry(entry);
+        this.groupStack.push(groupId);
+        this.currentGroupId = groupId;
+    }
+    groupCollapsed(label) {
+        this.group(label);
+        const group = this.groups.get(this.currentGroupId);
+        if (group) {
+            group.collapsed = true;
+        }
+    }
+    groupEnd() {
+        if (this.groupStack.length === 0) {
+            return;
+        }
+        const groupId = this.groupStack.pop();
+        this.currentGroupId =
+            this.groupStack.length > 0 ? this.groupStack[this.groupStack.length - 1] : null;
+        // Create group end entry
+        const entry = this.createEntry('info', 'none', []);
+        entry.isGroupEnd = true;
+        entry.groupId = groupId;
+        this.pushEntry(entry);
+    }
+    toggleGroupCollapse(groupId) {
+        const group = this.groups.get(groupId);
+        if (group) {
+            group.collapsed = !group.collapsed;
+            this.onChange?.();
+        }
+    }
+    // ─── Table Output ──────────────────────────────────────
+    table(data, columns) {
+        if (!data || typeof data !== 'object') {
+            this.log(data);
+            return;
+        }
+        // Convert to array if needed
+        const rows = Array.isArray(data) ? data : [data];
+        if (rows.length === 0) {
+            this.log('(empty)');
+            return;
+        }
+        // Get columns
+        const allColumns = new Set();
+        for (const row of rows) {
+            if (row && typeof row === 'object') {
+                for (const key of Object.keys(row)) {
+                    allColumns.add(key);
+                }
+            }
+        }
+        const cols = columns ?? Array.from(allColumns);
+        // Create table representation
+        const tableData = {
+            columns: cols,
+            rows: rows.map((row, i) => ({
+                index: i,
+                values: cols.map((col) => row?.[col]),
+            })),
+        };
+        const entry = this.createEntry('info', 'info', []);
+        entry.metadata = { type: 'table', data: tableData };
+        entry.message = `Table (${rows.length} rows)`;
+        this.pushEntry(entry);
+    }
+    time(label = 'default') {
+        this.timers.set(label, performance.now());
+    }
+    timeLog(label = 'default', ...args) {
+        const start = this.timers.get(label);
+        if (start === undefined) {
+            this.warn(`Timer '${label}' does not exist`);
+            return;
+        }
+        const elapsed = performance.now() - start;
+        this.log(`${label}: ${elapsed.toFixed(3)}ms`, ...args);
+    }
+    timeEnd(label = 'default') {
+        const start = this.timers.get(label);
+        if (start === undefined) {
+            this.warn(`Timer '${label}' does not exist`);
+            return;
+        }
+        const elapsed = performance.now() - start;
+        this.log(`${label}: ${elapsed.toFixed(3)}ms`);
+        this.timers.delete(label);
+    }
+    count(label = 'default') {
+        const count = (this.counters.get(label) ?? 0) + 1;
+        this.counters.set(label, count);
+        this.log(`${label}: ${count}`);
+    }
+    countReset(label = 'default') {
+        this.counters.delete(label);
+    }
+    // ─── Clear ─────────────────────────────────────────────
+    clear() {
+        if (!this.config.preserveLog) {
+            this.entries = [];
+            this.groups.clear();
+            this.groupStack = [];
+            this.currentGroupId = null;
+            this.lastEntryHash = '';
+            this.onClear?.();
+            this.onChange?.();
+        }
+    }
+    // ─── Entry Creation ────────────────────────────────────
+    addEntry(level, icon, args, tags = []) {
+        const entry = this.createEntry(level, icon, args, tags);
+        // Check for collapse
+        if (this.config.collapseRepeated) {
+            const hash = this.computeEntryHash(entry);
+            if (hash === this.lastEntryHash && this.entries.length > 0) {
+                this.entries[this.entries.length - 1].count++;
+                this.onChange?.();
+                return;
+            }
+            this.lastEntryHash = hash;
+        }
+        this.pushEntry(entry);
+    }
+    createEntry(level, icon, args, tags = []) {
+        const timestamp = Date.now();
+        const message = args
+            .map((arg) => {
+            if (typeof arg === 'string') {
+                return arg;
+            }
+            if (typeof arg === 'number' || typeof arg === 'boolean') {
+                return String(arg);
+            }
+            return inspectValue(arg).preview;
+        })
+            .join(' ');
+        const values = args.map((arg) => inspectValue(arg));
+        const entry = {
+            id: `log_${timestamp}_${Math.random().toString(36).substr(2, 9)}`,
+            level,
+            icon,
+            timestamp,
+            message,
+            values,
+            tags,
+            count: 1,
+        };
+        if (this.config.captureStackTrace &&
+            (level === 'error' || level === 'warn' || level === 'assert')) {
+            entry.stackTrace = captureStackTrace(this.config.stackTraceDepth);
+        }
+        if (this.config.showSource && entry.stackTrace && entry.stackTrace.length > 0) {
+            const frame = entry.stackTrace[0];
+            entry.source = `${frame.fileName}:${frame.lineNumber}`;
+        }
+        if (this.currentGroupId) {
+            entry.groupId = this.currentGroupId;
+            const group = this.groups.get(this.currentGroupId);
+            if (group) {
+                group.entries.push(entry);
+            }
+        }
+        return entry;
+    }
+    pushEntry(entry) {
+        this.entries.push(entry);
+        if (this.entries.length > this.config.maxEntries) {
+            this.entries.shift();
+        }
+        this.onEntryAdded?.(entry);
+        this.onChange?.();
+    }
+    computeEntryHash(entry) {
+        return `${entry.level}:${entry.message}:${entry.tags.join(',')}`;
+    }
+    // ─── Filtering ─────────────────────────────────────────
+    setLevelFilter(levels) {
+        this.levelFilter = new Set(levels);
+        this.onChange?.();
+    }
+    toggleLevelFilter(level) {
+        if (this.levelFilter.has(level)) {
+            this.levelFilter.delete(level);
+        }
+        else {
+            this.levelFilter.add(level);
+        }
+        this.onChange?.();
+    }
+    setTagFilter(tags) {
+        this.tagFilter = new Set(tags);
+        this.onChange?.();
+    }
+    setSearchFilter(search) {
+        this.searchFilter = search;
+        this.onChange?.();
+    }
+    setRegexFilter(pattern) {
+        if (pattern) {
+            try {
+                this.regexFilter = new RegExp(pattern, 'i');
+            }
+            catch {
+                this.regexFilter = null;
+            }
+        }
+        else {
+            this.regexFilter = null;
+        }
+        this.onChange?.();
+    }
+    getFilteredEntries() {
+        return this.entries.filter((entry) => {
+            // Level filter
+            if (!this.levelFilter.has(entry.level)) {
+                return false;
+            }
+            // Tag filter (if any tags specified, entry must have at least one)
+            if (this.tagFilter.size > 0) {
+                if (!entry.tags.some((tag) => this.tagFilter.has(tag))) {
+                    return false;
+                }
+            }
+            // Search filter
+            if (this.searchFilter) {
+                const searchLower = this.searchFilter.toLowerCase();
+                if (!entry.message.toLowerCase().includes(searchLower)) {
+                    return false;
+                }
+            }
+            // Regex filter
+            if (this.regexFilter) {
+                if (!this.regexFilter.test(entry.message)) {
+                    return false;
+                }
+            }
+            // Group collapse
+            if (entry.groupId && !entry.isGroupStart && !entry.isGroupEnd) {
+                const group = this.groups.get(entry.groupId);
+                if (group?.collapsed) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    // ─── Data Access ───────────────────────────────────────
+    getAllEntries() {
+        return this.entries;
+    }
+    getEntry(id) {
+        return this.entries.find((e) => e.id === id);
+    }
+    getStats() {
+        const byLevel = {
+            verbose: 0,
+            debug: 0,
+            info: 0,
+            warn: 0,
+            error: 0,
+            assert: 0,
+            custom: 0,
+        };
+        for (const entry of this.entries) {
+            byLevel[entry.level]++;
+        }
+        return {
+            total: this.entries.length,
+            byLevel,
+        };
+    }
+    // ─── Commands ──────────────────────────────────────────
+    registerCommand(command) {
+        this.commands.set(command.name, command);
+    }
+    unregisterCommand(name) {
+        this.commands.delete(name);
+    }
+    getCommands() {
+        return new Map(this.commands);
+    }
+    async executeCommand(input) {
+        if (!this.config.enableCommands) {
+            this.warn('Commands are disabled');
+            return;
+        }
+        const trimmed = input.trim();
+        // Check for command prefix
+        if (!trimmed.startsWith(this.config.commandPrefix)) {
+            // Treat as expression evaluation
+            return this.evaluate(trimmed);
+        }
+        // Parse command
+        const commandStr = trimmed.substring(this.config.commandPrefix.length);
+        const parts = commandStr.split(/\s+/);
+        const commandName = parts[0];
+        const args = parts.slice(1);
+        const command = this.commands.get(commandName);
+        if (!command) {
+            this.error(`Unknown command: ${commandName}`);
+            return;
+        }
+        try {
+            const result = await command.execute(args, this);
+            if (result) {
+                this.info(result);
+            }
+            return result;
+        }
+        catch (error) {
+            this.error(`Command error: ${error}`);
+        }
+    }
+    getAutocomplete(input) {
+        const trimmed = input.trim();
+        if (!trimmed.startsWith(this.config.commandPrefix)) {
+            // Autocomplete evaluation context
+            return Object.keys(this.evalContext).filter((k) => k.toLowerCase().startsWith(trimmed.toLowerCase()));
+        }
+        const commandStr = trimmed.substring(this.config.commandPrefix.length);
+        const parts = commandStr.split(/\s+/);
+        if (parts.length === 1) {
+            // Autocomplete command names
+            return Array.from(this.commands.keys())
+                .filter((name) => name.startsWith(parts[0]))
+                .map((name) => this.config.commandPrefix + name);
+        }
+        // Autocomplete command arguments
+        const command = this.commands.get(parts[0]);
+        if (command?.autocomplete) {
+            return command.autocomplete(parts[parts.length - 1], parts.slice(1, -1));
+        }
+        return [];
+    }
+    registerBuiltInCommands() {
+        this.registerCommand({
+            name: 'help',
+            description: 'Show available commands',
+            usage: '/help [command]',
+            examples: ['/help', '/help clear'],
+            execute: (args) => {
+                if (args.length > 0) {
+                    const cmd = this.commands.get(args[0]);
+                    if (cmd) {
+                        return `${cmd.name}: ${cmd.description}\nUsage: ${cmd.usage}\nExamples:\n  ${cmd.examples.join('\n  ')}`;
+                    }
+                    return `Unknown command: ${args[0]}`;
+                }
+                const lines = ['Available commands:'];
+                for (const [name, cmd] of this.commands) {
+                    lines.push(`  ${this.config.commandPrefix}${name} - ${cmd.description}`);
+                }
+                return lines.join('\n');
+            },
+        });
+        this.registerCommand({
+            name: 'clear',
+            description: 'Clear the console',
+            usage: '/clear',
+            examples: ['/clear'],
+            execute: () => {
+                this.clear();
+            },
+        });
+        this.registerCommand({
+            name: 'filter',
+            description: 'Set log level filter',
+            usage: '/filter [levels...]',
+            examples: ['/filter error warn', '/filter all'],
+            execute: (args) => {
+                if (args.length === 0 || args[0] === 'all') {
+                    this.setLevelFilter(['verbose', 'debug', 'info', 'warn', 'error', 'assert', 'custom']);
+                    return 'Showing all levels';
+                }
+                const levels = args;
+                this.setLevelFilter(levels);
+                return `Filtering: ${levels.join(', ')}`;
+            },
+            autocomplete: (partial) => {
+                const levels = [
+                    'verbose',
+                    'debug',
+                    'info',
+                    'warn',
+                    'error',
+                    'assert',
+                    'custom',
+                ];
+                return levels.filter((l) => l.startsWith(partial));
+            },
+        });
+        this.registerCommand({
+            name: 'search',
+            description: 'Search log messages',
+            usage: '/search <text>',
+            examples: ['/search error', '/search "connection failed"'],
+            execute: (args) => {
+                const query = args.join(' ');
+                this.setSearchFilter(query);
+                return `Searching: "${query}"`;
+            },
+        });
+        this.registerCommand({
+            name: 'export',
+            description: 'Export logs to JSON',
+            usage: '/export [filename]',
+            examples: ['/export', '/export debug-log'],
+            execute: (args) => {
+                const data = this.exportLogs();
+                // In a real implementation, this would trigger a download
+                this.info(`Exported ${this.entries.length} entries`);
+                return data;
+            },
+        });
+        this.registerCommand({
+            name: 'watch',
+            description: 'Add a watch expression',
+            usage: '/watch <expression>',
+            examples: ['/watch player.health', '/watch gameState.score'],
+            execute: (args) => {
+                const expression = args.join(' ');
+                this.addWatchExpression(expression);
+                return `Watching: ${expression}`;
+            },
+        });
+        this.registerCommand({
+            name: 'unwatch',
+            description: 'Remove a watch expression',
+            usage: '/unwatch <expression>',
+            examples: ['/unwatch player.health'],
+            execute: (args) => {
+                const expression = args.join(' ');
+                this.removeWatchExpression(expression);
+                return `Unwatched: ${expression}`;
+            },
+        });
+    }
+    // ─── Expression Evaluation ─────────────────────────────
+    setEvalContext(context) {
+        this.evalContext = context;
+    }
+    addToEvalContext(key, value) {
+        this.evalContext[key] = value;
+    }
+    evaluate(expression) {
+        try {
+            // Create a function with the context as local variables
+            const keys = Object.keys(this.evalContext);
+            const values = Object.values(this.evalContext);
+            const fn = new Function(...keys, `return (${expression})`);
+            const result = fn(...values);
+            const inspected = inspectValue(result);
+            this.info(`=> ${inspected.preview}`);
+            return inspected.preview;
+        }
+        catch (error) {
+            this.error(`Evaluation error: ${error}`);
+        }
+    }
+    // ─── Watch Expressions ─────────────────────────────────
+    addWatchExpression(expression, breakOnChange = false) {
+        this.watchExpressions.push({
+            id: `watch_${Date.now()}`,
+            expression,
+            lastValue: null,
+            lastError: null,
+            breakOnChange,
+        });
+    }
+    removeWatchExpression(expression) {
+        this.watchExpressions = this.watchExpressions.filter((w) => w.expression !== expression);
+    }
+    getWatchExpressions() {
+        return [...this.watchExpressions];
+    }
+    updateWatchExpressions() {
+        for (const watch of this.watchExpressions) {
+            try {
+                const keys = Object.keys(this.evalContext);
+                const values = Object.values(this.evalContext);
+                const fn = new Function(...keys, `return (${watch.expression})`);
+                const result = fn(...values);
+                const newValue = inspectValue(result);
+                // Check for change
+                if (watch.lastValue && watch.breakOnChange) {
+                    if (newValue.preview !== watch.lastValue.preview) {
+                        this.warn(`Watch changed: ${watch.expression} = ${newValue.preview} (was ${watch.lastValue.preview})`);
+                    }
+                }
+                watch.lastValue = newValue;
+                watch.lastError = null;
+            }
+            catch (error) {
+                watch.lastError = String(error);
+                watch.lastValue = null;
+            }
+        }
+    }
+    // ─── Export/Import ─────────────────────────────────────
+    exportLogs() {
+        return JSON.stringify({
+            version: 1,
+            timestamp: Date.now(),
+            entries: this.entries,
+            stats: this.getStats(),
+        }, null, 2);
+    }
+    importLogs(json) {
+        try {
+            const data = JSON.parse(json);
+            if (data.version === 1 && Array.isArray(data.entries)) {
+                this.entries = data.entries;
+                this.onChange?.();
+            }
+        }
+        catch (error) {
+            this.error(`Failed to import logs: ${error}`);
+        }
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setOnEntryAdded(callback) {
+        this.onEntryAdded = callback;
+    }
+    setOnChange(callback) {
+        this.onChange = callback;
+    }
+    setOnClear(callback) {
+        this.onClear = callback;
+    }
+    // ─── Format Helpers ────────────────────────────────────
+    formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        switch (this.config.timestampFormat) {
+            case 'absolute':
+                return (date.toLocaleTimeString('en-US', { hour12: false }) +
+                    '.' +
+                    String(date.getMilliseconds()).padStart(3, '0'));
+            case 'relative':
+                const now = Date.now();
+                const diff = now - timestamp;
+                if (diff < 1000) {
+                    return 'now';
+                }
+                if (diff < 60000) {
+                    return `${Math.floor(diff / 1000)}s ago`;
+                }
+                if (diff < 3600000) {
+                    return `${Math.floor(diff / 60000)}m ago`;
+                }
+                return `${Math.floor(diff / 3600000)}h ago`;
+            case 'both':
+                return `${date.toLocaleTimeString('en-US', { hour12: false })}.${String(date.getMilliseconds()).padStart(3, '0')}`;
+        }
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createConsolePro(config) {
+    return new ConsolePro(config);
+}
+function createGlobalConsole(config) {
+    const consolePro = new ConsolePro(config);
+    // Intercept global console methods
+    const originalConsole = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+        debug: console.debug,
+        group: console.group,
+        groupCollapsed: console.groupCollapsed,
+        groupEnd: console.groupEnd,
+        clear: console.clear,
+        time: console.time,
+        timeLog: console.timeLog,
+        timeEnd: console.timeEnd,
+        count: console.count,
+        countReset: console.countReset,
+        table: console.table,
+        assert: console.assert,
+    };
+    console.log = (...args) => {
+        consolePro.log(...args);
+        originalConsole.log(...args);
+    };
+    console.info = (...args) => {
+        consolePro.info(...args);
+        originalConsole.info(...args);
+    };
+    console.warn = (...args) => {
+        consolePro.warn(...args);
+        originalConsole.warn(...args);
+    };
+    console.error = (...args) => {
+        consolePro.error(...args);
+        originalConsole.error(...args);
+    };
+    console.debug = (...args) => {
+        consolePro.debug(...args);
+        originalConsole.debug(...args);
+    };
+    console.group = (label) => {
+        consolePro.group(label);
+        originalConsole.group(label);
+    };
+    console.groupCollapsed = (label) => {
+        consolePro.groupCollapsed(label);
+        originalConsole.groupCollapsed(label);
+    };
+    console.groupEnd = () => {
+        consolePro.groupEnd();
+        originalConsole.groupEnd();
+    };
+    console.clear = () => {
+        consolePro.clear();
+        originalConsole.clear();
+    };
+    console.time = (label) => {
+        consolePro.time(label);
+        originalConsole.time(label);
+    };
+    console.timeLog = (label, ...args) => {
+        consolePro.timeLog(label, ...args);
+        originalConsole.timeLog(label, ...args);
+    };
+    console.timeEnd = (label) => {
+        consolePro.timeEnd(label);
+        originalConsole.timeEnd(label);
+    };
+    console.count = (label) => {
+        consolePro.count(label);
+        originalConsole.count(label);
+    };
+    console.countReset = (label) => {
+        consolePro.countReset(label);
+        originalConsole.countReset(label);
+    };
+    console.table = (data, columns) => {
+        consolePro.table(data, columns);
+        originalConsole.table(data, columns);
+    };
+    console.assert = (condition, ...args) => {
+        consolePro.assert(condition, ...args);
+        originalConsole.assert(condition, ...args);
+    };
+    return consolePro;
+}
+
+export { ConsolePro, DEFAULT_CONSOLE_CONFIG, captureStackTrace, createConsolePro, createGlobalConsole, inspectValue };
+//# sourceMappingURL=ConsolePro.js.map