@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/breakpoints.js

@@ -0,0 +1,414 @@
+/**
+ * Breakpoint Manager
+ *
+ * Manages debugging breakpoints including:
+ * - Line breakpoints
+ * - Conditional breakpoints
+ * - Logpoints
+ * - Hit counts
+ * - Exception breakpoints
+ */
+/**
+ * Breakpoint Manager
+ */
+export class BreakpointManager {
+    _config = {
+        enabled: true,
+        showGutter: true,
+        allowConditional: true,
+        allowLogpoints: true,
+        maxPerFile: 50
+    };
+    _breakpoints = new Map();
+    _listeners = new Set();
+    _idCounter = 0;
+    /**
+     * Add a breakpoint
+     */
+    addBreakpoint(filePath, line, options) {
+        const id = `bp-${++this._idCounter}`;
+        const breakpoint = {
+            id,
+            filePath,
+            line,
+            type: options?.type || 'line',
+            state: options?.state || 'enabled',
+            condition: options?.condition,
+            logMessage: options?.logMessage,
+            hitCondition: options?.hitCondition,
+            hitCount: 0,
+            verified: false,
+            column: options?.column,
+            functionName: options?.functionName,
+            exceptionTypes: options?.exceptionTypes,
+            createdAt: new Date()
+        };
+        this._breakpoints.set(id, breakpoint);
+        this.notify();
+        return breakpoint;
+    }
+    /**
+     * Remove a breakpoint
+     */
+    removeBreakpoint(id) {
+        const result = this._breakpoints.delete(id);
+        if (result) {
+            this.notify();
+        }
+        return result;
+    }
+    /**
+     * Toggle breakpoint at line (add if not exists, remove if exists)
+     */
+    toggleBreakpoint(filePath, line) {
+        const existing = this.getBreakpointAtLine(filePath, line);
+        if (existing) {
+            this.removeBreakpoint(existing.id);
+            return null;
+        }
+        else {
+            return this.addBreakpoint(filePath, line);
+        }
+    }
+    /**
+     * Update a breakpoint
+     */
+    updateBreakpoint(id, updates) {
+        const breakpoint = this._breakpoints.get(id);
+        if (!breakpoint)
+            return null;
+        const updated = { ...breakpoint, ...updates };
+        this._breakpoints.set(id, updated);
+        this.notify();
+        return updated;
+    }
+    /**
+     * Enable a breakpoint
+     */
+    enableBreakpoint(id) {
+        const bp = this._breakpoints.get(id);
+        if (bp && bp.state === 'disabled') {
+            bp.state = 'enabled';
+            this.notify();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Disable a breakpoint
+     */
+    disableBreakpoint(id) {
+        const bp = this._breakpoints.get(id);
+        if (bp && bp.state === 'enabled') {
+            bp.state = 'disabled';
+            this.notify();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Toggle breakpoint enabled state
+     */
+    toggleBreakpointEnabled(id) {
+        const bp = this._breakpoints.get(id);
+        if (bp) {
+            bp.state = bp.state === 'enabled' ? 'disabled' : 'enabled';
+            this.notify();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get breakpoint by ID
+     */
+    getBreakpoint(id) {
+        return this._breakpoints.get(id);
+    }
+    /**
+     * Get breakpoint at specific line
+     */
+    getBreakpointAtLine(filePath, line) {
+        for (const bp of this._breakpoints.values()) {
+            if (bp.filePath === filePath && bp.line === line) {
+                return bp;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get all breakpoints for a file
+     */
+    getBreakpointsForFile(filePath) {
+        const breakpoints = [];
+        for (const bp of this._breakpoints.values()) {
+            if (bp.filePath === filePath) {
+                breakpoints.push(bp);
+            }
+        }
+        return breakpoints.sort((a, b) => a.line - b.line);
+    }
+    /**
+     * Get all breakpoints
+     */
+    getAllBreakpoints() {
+        return [...this._breakpoints.values()].sort((a, b) => {
+            const pathCompare = a.filePath.localeCompare(b.filePath);
+            if (pathCompare !== 0)
+                return pathCompare;
+            return a.line - b.line;
+        });
+    }
+    /**
+     * Get breakpoints grouped by file
+     */
+    getBreakpointsByFile() {
+        const byFile = new Map();
+        for (const bp of this._breakpoints.values()) {
+            if (!byFile.has(bp.filePath)) {
+                byFile.set(bp.filePath, []);
+            }
+            byFile.get(bp.filePath).push(bp);
+        }
+        // Sort each file's breakpoints by line
+        for (const [path, bps] of byFile) {
+            byFile.set(path, bps.sort((a, b) => a.line - b.line));
+        }
+        return byFile;
+    }
+    /**
+     * Clear all breakpoints for a file
+     */
+    clearFileBreakpoints(filePath) {
+        let count = 0;
+        for (const bp of [...this._breakpoints.values()]) {
+            if (bp.filePath === filePath) {
+                this._breakpoints.delete(bp.id);
+                count++;
+            }
+        }
+        if (count > 0) {
+            this.notify();
+        }
+        return count;
+    }
+    /**
+     * Clear all breakpoints
+     */
+    clearAllBreakpoints() {
+        const count = this._breakpoints.size;
+        this._breakpoints.clear();
+        if (count > 0) {
+            this.notify();
+        }
+        return count;
+    }
+    /**
+     * Enable all breakpoints
+     */
+    enableAllBreakpoints() {
+        for (const bp of this._breakpoints.values()) {
+            if (bp.state === 'disabled') {
+                bp.state = 'enabled';
+            }
+        }
+        this.notify();
+    }
+    /**
+     * Disable all breakpoints
+     */
+    disableAllBreakpoints() {
+        for (const bp of this._breakpoints.values()) {
+            if (bp.state === 'enabled') {
+                bp.state = 'disabled';
+            }
+        }
+        this.notify();
+    }
+    /**
+     * Mark breakpoint as verified by debugger
+     */
+    verifyBreakpoint(id, verified, errorMessage) {
+        const bp = this._breakpoints.get(id);
+        if (bp) {
+            bp.verified = verified;
+            bp.state = verified ? 'enabled' : 'invalid';
+            bp.errorMessage = errorMessage;
+            this.notify();
+        }
+    }
+    /**
+     * Increment hit count for breakpoint
+     */
+    incrementHitCount(id) {
+        const bp = this._breakpoints.get(id);
+        if (bp) {
+            bp.hitCount++;
+            this.notify();
+            return bp.hitCount;
+        }
+        return 0;
+    }
+    /**
+     * Reset hit counts for all breakpoints
+     */
+    resetHitCounts() {
+        for (const bp of this._breakpoints.values()) {
+            bp.hitCount = 0;
+        }
+        this.notify();
+    }
+    /**
+     * Check if breakpoint should trigger based on conditions
+     */
+    shouldBreakpointTrigger(id) {
+        const bp = this._breakpoints.get(id);
+        if (!bp || bp.state !== 'enabled')
+            return false;
+        // Check hit condition
+        if (bp.hitCondition) {
+            const count = bp.hitCount;
+            try {
+                // Simple hit condition evaluation
+                if (bp.hitCondition.startsWith('>=')) {
+                    const value = parseInt(bp.hitCondition.slice(2).trim());
+                    if (count < value)
+                        return false;
+                }
+                else if (bp.hitCondition.startsWith('==')) {
+                    const value = parseInt(bp.hitCondition.slice(2).trim());
+                    if (count !== value)
+                        return false;
+                }
+                else if (bp.hitCondition.startsWith('%')) {
+                    const match = bp.hitCondition.match(/%\s*(\d+)\s*==\s*(\d+)/);
+                    if (match) {
+                        const divisor = parseInt(match[1]);
+                        const remainder = parseInt(match[2]);
+                        if (count % divisor !== remainder)
+                            return false;
+                    }
+                }
+            }
+            catch {
+                // Invalid hit condition, trigger anyway
+            }
+        }
+        return true;
+    }
+    /**
+     * Get count
+     */
+    getCount(filePath) {
+        if (filePath) {
+            return this.getBreakpointsForFile(filePath).length;
+        }
+        return this._breakpoints.size;
+    }
+    /**
+     * Get config
+     */
+    get config() {
+        return { ...this._config };
+    }
+    /**
+     * Update config
+     */
+    setConfig(config) {
+        this._config = { ...this._config, ...config };
+        this.notify();
+    }
+    /**
+     * Enable/disable globally
+     */
+    setEnabled(enabled) {
+        this._config.enabled = enabled;
+        this.notify();
+    }
+    /**
+     * Check if enabled
+     */
+    isEnabled() {
+        return this._config.enabled;
+    }
+    /**
+     * Subscribe to changes
+     */
+    subscribe(listener) {
+        this._listeners.add(listener);
+        return () => this._listeners.delete(listener);
+    }
+    /**
+     * Notify listeners
+     */
+    notify() {
+        for (const listener of this._listeners) {
+            listener();
+        }
+    }
+    /**
+     * Export breakpoints (for persistence)
+     */
+    exportBreakpoints() {
+        return JSON.stringify([...this._breakpoints.values()]);
+    }
+    /**
+     * Import breakpoints (from persistence)
+     */
+    importBreakpoints(json) {
+        try {
+            const breakpoints = JSON.parse(json);
+            this._breakpoints.clear();
+            for (const bp of breakpoints) {
+                bp.createdAt = new Date(bp.createdAt);
+                this._breakpoints.set(bp.id, bp);
+            }
+            this.notify();
+        }
+        catch (e) {
+            console.error('Failed to import breakpoints:', e);
+        }
+    }
+    /**
+     * Clean up
+     */
+    destroy() {
+        this._listeners.clear();
+        this._breakpoints.clear();
+    }
+}
+/**
+ * Create a new BreakpointManager instance
+ */
+export function createBreakpointManager() {
+    return new BreakpointManager();
+}
+/**
+ * Get icon for breakpoint type
+ */
+export function getBreakpointIcon(breakpoint) {
+    if (breakpoint.type === 'logpoint')
+        return '◆';
+    if (breakpoint.type === 'conditional')
+        return '◉';
+    if (breakpoint.type === 'function')
+        return 'ƒ';
+    if (breakpoint.type === 'exception')
+        return '⚡';
+    return '●';
+}
+/**
+ * Get color for breakpoint state
+ */
+export function getBreakpointColor(breakpoint) {
+    if (breakpoint.state === 'disabled')
+        return '#6c6c6c';
+    if (breakpoint.state === 'invalid')
+        return '#888888';
+    if (breakpoint.state === 'pending')
+        return '#ff8c00';
+    if (breakpoint.type === 'logpoint')
+        return '#f9e64f';
+    if (breakpoint.type === 'conditional')
+        return '#f44747';
+    return '#f44747';
+}

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

@@ -0,0 +1,108 @@
+/**
+ * Command System
+ *
+ * Provides a centralized command registry for the editor.
+ * Commands can be executed via keyboard shortcuts or the command palette.
+ */
+import type { EditorState } from './state';
+import { type FoldPreset } from './semantic-analyzer';
+/**
+ * Command definition
+ */
+export interface Command {
+    /** Unique command identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Category for grouping */
+    category: string;
+    /** Description */
+    description?: string;
+    /** Keyboard shortcut (display only) */
+    shortcut?: string;
+    /** Icon (unicode or emoji) */
+    icon?: string;
+    /** Execute the command */
+    execute: () => void | Promise<void>;
+    /** Check if command is enabled */
+    isEnabled?: () => boolean;
+}
+/**
+ * Command category
+ */
+export interface CommandCategory {
+    id: string;
+    label: string;
+    icon?: string;
+}
+/**
+ * Command registry
+ */
+declare class CommandRegistry {
+    private commands;
+    private categories;
+    /**
+     * Register a command
+     */
+    register(command: Command): () => void;
+    /**
+     * Register multiple commands
+     */
+    registerMany(commands: Command[]): () => void;
+    /**
+     * Register a category
+     */
+    registerCategory(category: CommandCategory): void;
+    /**
+     * Get a command by ID
+     */
+    get(id: string): Command | undefined;
+    /**
+     * Execute a command by ID
+     */
+    execute(id: string): Promise<boolean>;
+    /**
+     * Get all commands
+     */
+    getAll(): Command[];
+    /**
+     * Get commands by category
+     */
+    getByCategory(categoryId: string): Command[];
+    /**
+     * Search commands
+     */
+    search(query: string): Command[];
+    /**
+     * Get all categories
+     */
+    getCategories(): CommandCategory[];
+    /**
+     * Clear all commands
+     */
+    clear(): void;
+}
+/**
+ * Get the global command registry
+ */
+export declare function getCommandRegistry(): CommandRegistry;
+/**
+ * Semantic fold action types
+ */
+export type SemanticFoldAction = 'fold' | 'unfold' | 'toggle' | 'focus';
+/**
+ * Create semantic fold commands for the editor
+ */
+export declare function createSemanticFoldCommands(editorState: EditorState, options: {
+    onFoldLines?: (startLine: number, endLine: number) => void;
+    onUnfoldLines?: (startLine: number, endLine: number) => void;
+    onFoldAll?: () => void;
+    onUnfoldAll?: () => void;
+    onApplyPreset?: (preset: FoldPreset) => void;
+    getLanguage?: () => string;
+}): Command[];
+/**
+ * Register semantic fold commands with the global registry
+ */
+export declare function registerSemanticFoldCommands(editorState: EditorState, options: Parameters<typeof createSemanticFoldCommands>[1]): () => void;
+export {};