@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/bracket-healer.js

@@ -0,0 +1,406 @@
+/**
+ * Bracket Healer
+ *
+ * Intelligent bracket completion and morphing system.
+ * Detects mismatched brackets and suggests "ghost brackets"
+ * to heal document structure.
+ */
+const DEFAULT_PAIRS = [
+    { open: '(', close: ')' },
+    { open: '[', close: ']' },
+    { open: '{', close: '}' },
+    { open: '<', close: '>', language: ['html', 'xml', 'jsx', 'tsx', 'svelte', 'vue'] }
+];
+const DEFAULT_CONFIG = {
+    pairs: DEFAULT_PAIRS,
+    minConfidence: 0.5,
+    maxGhosts: 5,
+    debounceMs: 150
+};
+/**
+ * Bracket Healer Manager
+ */
+export class BracketHealer {
+    config;
+    state;
+    language = 'javascript';
+    debounceTimer = null;
+    listeners = new Set();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.state = {
+            matches: [],
+            ghosts: [],
+            mismatches: [],
+            enabled: true
+        };
+    }
+    /**
+     * Set current language
+     */
+    setLanguage(language) {
+        this.language = language;
+    }
+    /**
+     * Enable/disable healing
+     */
+    setEnabled(enabled) {
+        this.state.enabled = enabled;
+        if (!enabled) {
+            this.state = { ...this.state, matches: [], ghosts: [], mismatches: [] };
+        }
+        this.notify();
+    }
+    /**
+     * Analyze document content
+     */
+    analyze(content) {
+        if (!this.state.enabled)
+            return;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.performAnalysis(content);
+        }, this.config.debounceMs);
+    }
+    /**
+     * Analyze immediately (no debounce)
+     */
+    analyzeImmediate(content) {
+        if (!this.state.enabled)
+            return;
+        this.performAnalysis(content);
+    }
+    /**
+     * Perform bracket analysis
+     */
+    performAnalysis(content) {
+        const lines = content.split('\n');
+        const tokens = this.extractBrackets(lines);
+        const { matches, mismatches } = this.matchBrackets(tokens);
+        const ghosts = this.generateGhosts(matches, mismatches, lines);
+        this.state = {
+            ...this.state,
+            matches,
+            mismatches,
+            ghosts: ghosts.slice(0, this.config.maxGhosts)
+        };
+        this.notify();
+    }
+    /**
+     * Extract all brackets from content
+     */
+    extractBrackets(lines) {
+        const tokens = [];
+        const activePairs = this.getActivePairs();
+        for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+            const line = lines[lineNum];
+            let inString = false;
+            let stringChar = '';
+            let inComment = false;
+            for (let col = 0; col < line.length; col++) {
+                const char = line[col];
+                const prevChar = col > 0 ? line[col - 1] : '';
+                // Skip escaped characters
+                if (prevChar === '\\')
+                    continue;
+                // Track string state
+                if (!inComment && (char === '"' || char === "'" || char === '`')) {
+                    if (!inString) {
+                        inString = true;
+                        stringChar = char;
+                    }
+                    else if (char === stringChar) {
+                        inString = false;
+                    }
+                    continue;
+                }
+                // Track comments (basic detection)
+                if (!inString && char === '/' && line[col + 1] === '/') {
+                    break; // Rest of line is comment
+                }
+                if (inString || inComment)
+                    continue;
+                // Check for bracket
+                for (const pair of activePairs) {
+                    if (char === pair.open) {
+                        tokens.push({
+                            char,
+                            position: { line: lineNum, column: col },
+                            isOpen: true,
+                            pair
+                        });
+                    }
+                    else if (char === pair.close) {
+                        tokens.push({
+                            char,
+                            position: { line: lineNum, column: col },
+                            isOpen: false,
+                            pair
+                        });
+                    }
+                }
+            }
+        }
+        return tokens;
+    }
+    /**
+     * Get bracket pairs active for current language
+     */
+    getActivePairs() {
+        return this.config.pairs.filter((pair) => {
+            if (!pair.language)
+                return true;
+            return pair.language.includes(this.language);
+        });
+    }
+    /**
+     * Match brackets and find mismatches
+     */
+    matchBrackets(tokens) {
+        const matches = [];
+        const mismatches = [];
+        const stack = [];
+        let depth = 0;
+        for (const token of tokens) {
+            if (token.isOpen) {
+                stack.push({ token, depth });
+                depth++;
+            }
+            else {
+                // Look for matching open bracket
+                let matched = false;
+                for (let i = stack.length - 1; i >= 0; i--) {
+                    const openEntry = stack[i];
+                    if (openEntry.token.pair.close === token.char) {
+                        // Found match
+                        matches.push({
+                            openPos: openEntry.token.position,
+                            closePos: token.position,
+                            type: openEntry.token.pair,
+                            isComplete: true,
+                            depth: openEntry.depth
+                        });
+                        stack.splice(i, 1);
+                        matched = true;
+                        depth = Math.max(0, depth - 1);
+                        break;
+                    }
+                }
+                if (!matched) {
+                    // Unexpected closing bracket
+                    if (stack.length > 0) {
+                        const lastOpen = stack[stack.length - 1].token;
+                        mismatches.push({
+                            position: token.position,
+                            character: token.char,
+                            expected: lastOpen.pair.close,
+                            issue: 'mismatched',
+                            severity: 'error'
+                        });
+                    }
+                    else {
+                        mismatches.push({
+                            position: token.position,
+                            character: token.char,
+                            issue: 'unexpected',
+                            severity: 'error'
+                        });
+                    }
+                }
+            }
+        }
+        // Remaining stack items are unclosed
+        for (const entry of stack) {
+            matches.push({
+                openPos: entry.token.position,
+                closePos: null,
+                type: entry.token.pair,
+                isComplete: false,
+                depth: entry.depth
+            });
+            mismatches.push({
+                position: entry.token.position,
+                character: entry.token.char,
+                issue: 'unclosed',
+                severity: 'warning'
+            });
+        }
+        return { matches, mismatches };
+    }
+    /**
+     * Generate ghost bracket suggestions
+     */
+    generateGhosts(matches, mismatches, lines) {
+        const ghosts = [];
+        const dismissedIds = new Set(this.state.ghosts.filter((g) => g.dismissed).map((g) => g.id));
+        for (const match of matches) {
+            if (!match.isComplete) {
+                // Suggest closing bracket
+                const ghost = this.suggestClosingBracket(match, lines);
+                if (ghost && ghost.confidence >= this.config.minConfidence) {
+                    ghost.dismissed = dismissedIds.has(ghost.id);
+                    ghosts.push(ghost);
+                }
+            }
+        }
+        // Sort by confidence
+        ghosts.sort((a, b) => b.confidence - a.confidence);
+        return ghosts;
+    }
+    /**
+     * Suggest where to place a closing bracket
+     */
+    suggestClosingBracket(match, lines) {
+        const openLine = lines[match.openPos.line];
+        let suggestedLine = match.openPos.line;
+        let suggestedCol = openLine.length;
+        let confidence = 0.6;
+        let reason = 'End of line containing opening bracket';
+        // Heuristics for better placement
+        // 1. If it's a function/block, find matching indentation
+        const openIndent = this.getIndentation(openLine);
+        for (let i = match.openPos.line + 1; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            if (trimmed === '')
+                continue;
+            const indent = this.getIndentation(line);
+            // Found a line with same or less indentation
+            if (indent <= openIndent && trimmed.length > 0) {
+                // Place before this line
+                suggestedLine = i - 1;
+                suggestedCol = lines[suggestedLine].length;
+                confidence = 0.8;
+                reason = 'Before dedented line';
+                break;
+            }
+            // Found potential end marker (return, }, etc.)
+            if (indent === openIndent && /^(return|break|continue|\})/.test(trimmed)) {
+                suggestedLine = i - 1;
+                suggestedCol = lines[suggestedLine].length;
+                confidence = 0.85;
+                reason = 'Before control flow statement';
+                break;
+            }
+        }
+        // 2. For simple brackets on same line, suggest end of line
+        if (match.openPos.line === suggestedLine) {
+            confidence = 0.9;
+            reason = 'Same line completion';
+        }
+        const id = `ghost-${match.openPos.line}-${match.openPos.column}-${match.type.close}`;
+        return {
+            id,
+            position: { line: suggestedLine, column: suggestedCol },
+            character: match.type.close,
+            type: 'close',
+            matchPosition: match.openPos,
+            confidence,
+            reason,
+            dismissed: false
+        };
+    }
+    /**
+     * Get line indentation level
+     */
+    getIndentation(line) {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+    }
+    /**
+     * Accept a ghost bracket suggestion
+     */
+    acceptGhost(id) {
+        const ghost = this.state.ghosts.find((g) => g.id === id);
+        if (ghost) {
+            // Remove from suggestions
+            this.state.ghosts = this.state.ghosts.filter((g) => g.id !== id);
+            this.notify();
+        }
+        return ghost ?? null;
+    }
+    /**
+     * Dismiss a ghost bracket suggestion
+     */
+    dismissGhost(id) {
+        const ghost = this.state.ghosts.find((g) => g.id === id);
+        if (ghost) {
+            ghost.dismissed = true;
+            this.notify();
+        }
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get ghost brackets (non-dismissed only)
+     */
+    getActiveGhosts() {
+        return this.state.ghosts.filter((g) => !g.dismissed);
+    }
+    /**
+     * Get mismatches
+     */
+    getMismatches() {
+        return [...this.state.mismatches];
+    }
+    /**
+     * Find matching bracket for position
+     */
+    findMatchingBracket(position) {
+        for (const match of this.state.matches) {
+            if (match.openPos.line === position.line &&
+                match.openPos.column === position.column &&
+                match.closePos) {
+                return match.closePos;
+            }
+            if (match.closePos &&
+                match.closePos.line === position.line &&
+                match.closePos.column === position.column) {
+                return match.openPos;
+            }
+        }
+        return null;
+    }
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * Notify listeners
+     */
+    notify() {
+        const state = this.getState();
+        for (const listener of this.listeners) {
+            try {
+                listener(state);
+            }
+            catch (e) {
+                console.error('[BracketHealer] Listener error:', e);
+            }
+        }
+    }
+    /**
+     * Destroy and cleanup
+     */
+    destroy() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.listeners.clear();
+    }
+}
+/**
+ * Create a bracket healer instance
+ */
+export function createBracketHealer(config) {
+    return new BracketHealer(config);
+}

package/dist/components/editor/core/breakpoints.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Breakpoint Manager
+ *
+ * Manages debugging breakpoints including:
+ * - Line breakpoints
+ * - Conditional breakpoints
+ * - Logpoints
+ * - Hit counts
+ * - Exception breakpoints
+ */
+export interface Position {
+    line: number;
+    column?: number;
+}
+export type BreakpointType = 'line' | 'conditional' | 'logpoint' | 'function' | 'exception';
+export type BreakpointState = 'enabled' | 'disabled' | 'pending' | 'invalid';
+export interface Breakpoint {
+    /** Unique identifier */
+    id: string;
+    /** File path */
+    filePath: string;
+    /** Line number (0-based) */
+    line: number;
+    /** Column (optional, for inline breakpoints) */
+    column?: number;
+    /** Breakpoint type */
+    type: BreakpointType;
+    /** Current state */
+    state: BreakpointState;
+    /** Condition expression (for conditional breakpoints) */
+    condition?: string;
+    /** Log message (for logpoints) */
+    logMessage?: string;
+    /** Hit count condition (e.g., ">= 5", "% 3 == 0") */
+    hitCondition?: string;
+    /** Current hit count */
+    hitCount: number;
+    /** Whether breakpoint is verified by debugger */
+    verified: boolean;
+    /** Error message if invalid */
+    errorMessage?: string;
+    /** Function name (for function breakpoints) */
+    functionName?: string;
+    /** Exception types (for exception breakpoints) */
+    exceptionTypes?: string[];
+    /** Timestamp when created */
+    createdAt: Date;
+}
+export interface BreakpointsConfig {
+    /** Whether breakpoints are enabled globally */
+    enabled: boolean;
+    /** Show breakpoint gutter */
+    showGutter: boolean;
+    /** Allow conditional breakpoints */
+    allowConditional: boolean;
+    /** Allow logpoints */
+    allowLogpoints: boolean;
+    /** Maximum breakpoints per file */
+    maxPerFile: number;
+}
+type Listener = () => void;
+/**
+ * Breakpoint Manager
+ */
+export declare class BreakpointManager {
+    private _config;
+    private _breakpoints;
+    private _listeners;
+    private _idCounter;
+    /**
+     * Add a breakpoint
+     */
+    addBreakpoint(filePath: string, line: number, options?: Partial<Omit<Breakpoint, 'id' | 'filePath' | 'line' | 'hitCount' | 'verified' | 'createdAt'>>): Breakpoint;
+    /**
+     * Remove a breakpoint
+     */
+    removeBreakpoint(id: string): boolean;
+    /**
+     * Toggle breakpoint at line (add if not exists, remove if exists)
+     */
+    toggleBreakpoint(filePath: string, line: number): Breakpoint | null;
+    /**
+     * Update a breakpoint
+     */
+    updateBreakpoint(id: string, updates: Partial<Omit<Breakpoint, 'id' | 'createdAt'>>): Breakpoint | null;
+    /**
+     * Enable a breakpoint
+     */
+    enableBreakpoint(id: string): boolean;
+    /**
+     * Disable a breakpoint
+     */
+    disableBreakpoint(id: string): boolean;
+    /**
+     * Toggle breakpoint enabled state
+     */
+    toggleBreakpointEnabled(id: string): boolean;
+    /**
+     * Get breakpoint by ID
+     */
+    getBreakpoint(id: string): Breakpoint | undefined;
+    /**
+     * Get breakpoint at specific line
+     */
+    getBreakpointAtLine(filePath: string, line: number): Breakpoint | undefined;
+    /**
+     * Get all breakpoints for a file
+     */
+    getBreakpointsForFile(filePath: string): Breakpoint[];
+    /**
+     * Get all breakpoints
+     */
+    getAllBreakpoints(): Breakpoint[];
+    /**
+     * Get breakpoints grouped by file
+     */
+    getBreakpointsByFile(): Map<string, Breakpoint[]>;
+    /**
+     * Clear all breakpoints for a file
+     */
+    clearFileBreakpoints(filePath: string): number;
+    /**
+     * Clear all breakpoints
+     */
+    clearAllBreakpoints(): number;
+    /**
+     * Enable all breakpoints
+     */
+    enableAllBreakpoints(): void;
+    /**
+     * Disable all breakpoints
+     */
+    disableAllBreakpoints(): void;
+    /**
+     * Mark breakpoint as verified by debugger
+     */
+    verifyBreakpoint(id: string, verified: boolean, errorMessage?: string): void;
+    /**
+     * Increment hit count for breakpoint
+     */
+    incrementHitCount(id: string): number;
+    /**
+     * Reset hit counts for all breakpoints
+     */
+    resetHitCounts(): void;
+    /**
+     * Check if breakpoint should trigger based on conditions
+     */
+    shouldBreakpointTrigger(id: string): boolean;
+    /**
+     * Get count
+     */
+    getCount(filePath?: string): number;
+    /**
+     * Get config
+     */
+    get config(): BreakpointsConfig;
+    /**
+     * Update config
+     */
+    setConfig(config: Partial<BreakpointsConfig>): void;
+    /**
+     * Enable/disable globally
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Subscribe to changes
+     */
+    subscribe(listener: Listener): () => void;
+    /**
+     * Notify listeners
+     */
+    private notify;
+    /**
+     * Export breakpoints (for persistence)
+     */
+    exportBreakpoints(): string;
+    /**
+     * Import breakpoints (from persistence)
+     */
+    importBreakpoints(json: string): void;
+    /**
+     * Clean up
+     */
+    destroy(): void;
+}
+/**
+ * Create a new BreakpointManager instance
+ */
+export declare function createBreakpointManager(): BreakpointManager;
+/**
+ * Get icon for breakpoint type
+ */
+export declare function getBreakpointIcon(breakpoint: Breakpoint): string;
+/**
+ * Get color for breakpoint state
+ */
+export declare function getBreakpointColor(breakpoint: Breakpoint): string;
+export {};