@nocturnium/svelte-ide 1.0.0-rc.1

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

@@ -0,0 +1,246 @@
+/**
+ * Command System
+ *
+ * Provides a centralized command registry for the editor.
+ * Commands can be executed via keyboard shortcuts or the command palette.
+ */
+import { getSemanticAnalyzer, DEFAULT_FOLD_PRESETS } from './semantic-analyzer';
+/**
+ * Command registry
+ */
+class CommandRegistry {
+    commands = new Map();
+    categories = new Map();
+    /**
+     * Register a command
+     */
+    register(command) {
+        this.commands.set(command.id, command);
+        return () => this.commands.delete(command.id);
+    }
+    /**
+     * Register multiple commands
+     */
+    registerMany(commands) {
+        const unsubscribes = commands.map((cmd) => this.register(cmd));
+        return () => unsubscribes.forEach((unsub) => unsub());
+    }
+    /**
+     * Register a category
+     */
+    registerCategory(category) {
+        this.categories.set(category.id, category);
+    }
+    /**
+     * Get a command by ID
+     */
+    get(id) {
+        return this.commands.get(id);
+    }
+    /**
+     * Execute a command by ID
+     */
+    async execute(id) {
+        const command = this.commands.get(id);
+        if (!command)
+            return false;
+        if (command.isEnabled && !command.isEnabled()) {
+            return false;
+        }
+        await command.execute();
+        return true;
+    }
+    /**
+     * Get all commands
+     */
+    getAll() {
+        return Array.from(this.commands.values());
+    }
+    /**
+     * Get commands by category
+     */
+    getByCategory(categoryId) {
+        return this.getAll().filter((cmd) => cmd.category === categoryId);
+    }
+    /**
+     * Search commands
+     */
+    search(query) {
+        const q = query.toLowerCase();
+        return this.getAll().filter((cmd) => cmd.label.toLowerCase().includes(q) ||
+            cmd.description?.toLowerCase().includes(q) ||
+            cmd.category.toLowerCase().includes(q));
+    }
+    /**
+     * Get all categories
+     */
+    getCategories() {
+        return Array.from(this.categories.values());
+    }
+    /**
+     * Clear all commands
+     */
+    clear() {
+        this.commands.clear();
+    }
+}
+// Global command registry
+let globalRegistry = null;
+/**
+ * Get the global command registry
+ */
+export function getCommandRegistry() {
+    if (!globalRegistry) {
+        globalRegistry = new CommandRegistry();
+        initializeCategories(globalRegistry);
+    }
+    return globalRegistry;
+}
+/**
+ * Initialize default categories
+ */
+function initializeCategories(registry) {
+    registry.registerCategory({ id: 'fold', label: 'Folding', icon: '▼' });
+    registry.registerCategory({ id: 'fold.semantic', label: 'Semantic Folding', icon: '◇' });
+    registry.registerCategory({ id: 'fold.preset', label: 'Fold Presets', icon: '◈' });
+    registry.registerCategory({ id: 'navigation', label: 'Navigation', icon: '→' });
+    registry.registerCategory({ id: 'edit', label: 'Edit', icon: '✎' });
+    registry.registerCategory({ id: 'view', label: 'View', icon: '◉' });
+    registry.registerCategory({ id: 'search', label: 'Search', icon: '⌕' });
+}
+/**
+ * Create semantic fold commands for the editor
+ */
+export function createSemanticFoldCommands(editorState, options) {
+    const analyzer = getSemanticAnalyzer();
+    const commands = [];
+    // Helper to get regions
+    const getRegions = () => {
+        const language = options.getLanguage?.() || 'typescript';
+        return analyzer.analyze(editorState.lines, language);
+    };
+    // Helper to fold by category
+    const foldByCategory = (category, action) => {
+        const regions = getRegions();
+        const categoryRegions = analyzer.getByCategory(regions, category);
+        for (const region of categoryRegions) {
+            if (action === 'fold' && options.onFoldLines) {
+                options.onFoldLines(region.startLine, region.endLine);
+            }
+            else if (action === 'unfold' && options.onUnfoldLines) {
+                options.onUnfoldLines(region.startLine, region.endLine);
+            }
+        }
+    };
+    // Category-based fold commands
+    const categoryCommands = [
+        { category: 'imports', label: 'Imports', icon: '↓' },
+        { category: 'exports', label: 'Exports', icon: '↑' },
+        { category: 'types', label: 'Types/Interfaces', icon: 'T' },
+        { category: 'function', label: 'Functions', icon: 'ƒ' },
+        { category: 'class', label: 'Classes', icon: 'C' },
+        { category: 'tests', label: 'Tests', icon: '✓' },
+        { category: 'comments', label: 'Comments', icon: '#' },
+        { category: 'error-handling', label: 'Error Handling', icon: '!' },
+        { category: 'logging', label: 'Logging', icon: '⊙' },
+        { category: 'private', label: 'Private Members', icon: '_' }
+    ];
+    // Add fold/unfold commands for each category
+    for (const { category, label, icon } of categoryCommands) {
+        commands.push({
+            id: `fold.semantic.${category}`,
+            label: `Fold ${label}`,
+            category: 'fold.semantic',
+            description: `Collapse all ${label.toLowerCase()} in the document`,
+            icon,
+            execute: () => foldByCategory(category, 'fold')
+        }, {
+            id: `unfold.semantic.${category}`,
+            label: `Unfold ${label}`,
+            category: 'fold.semantic',
+            description: `Expand all ${label.toLowerCase()} in the document`,
+            icon,
+            execute: () => foldByCategory(category, 'unfold')
+        });
+    }
+    // Preset commands
+    for (const preset of DEFAULT_FOLD_PRESETS) {
+        commands.push({
+            id: `fold.preset.${preset.id}`,
+            label: `Apply Preset: ${preset.name}`,
+            category: 'fold.preset',
+            description: preset.description,
+            icon: preset.icon,
+            execute: () => options.onApplyPreset?.(preset)
+        });
+    }
+    // General fold commands
+    commands.push({
+        id: 'fold.all',
+        label: 'Fold All',
+        category: 'fold',
+        description: 'Collapse all foldable regions',
+        shortcut: 'Ctrl+K Ctrl+0',
+        icon: '▼',
+        execute: () => options.onFoldAll?.()
+    }, {
+        id: 'unfold.all',
+        label: 'Unfold All',
+        category: 'fold',
+        description: 'Expand all folded regions',
+        shortcut: 'Ctrl+K Ctrl+J',
+        icon: '▶',
+        execute: () => options.onUnfoldAll?.()
+    }, {
+        id: 'fold.showOnlyPublicAPI',
+        label: 'Show Only Public API',
+        category: 'fold.semantic',
+        description: 'Fold everything except exports and public methods',
+        icon: '◉',
+        execute: () => {
+            // Fold all first
+            options.onFoldAll?.();
+            // Then unfold exports
+            foldByCategory('exports', 'unfold');
+        }
+    }, {
+        id: 'fold.hideBoilerplate',
+        label: 'Hide Boilerplate',
+        category: 'fold.semantic',
+        description: 'Fold imports, types, and constants',
+        icon: '◌',
+        execute: () => {
+            foldByCategory('imports', 'fold');
+            foldByCategory('types', 'fold');
+            foldByCategory('constants', 'fold');
+        }
+    }, {
+        id: 'fold.focusFunction',
+        label: 'Focus Current Function',
+        category: 'fold.semantic',
+        description: 'Fold everything except the current function',
+        icon: 'ƒ',
+        execute: () => {
+            const cursorLine = editorState.selection.head.line;
+            const regions = getRegions();
+            const functions = analyzer.getByCategory(regions, 'function');
+            // Find function containing cursor
+            const currentFn = functions.find((r) => r.startLine <= cursorLine && r.endLine >= cursorLine);
+            if (currentFn) {
+                // Fold all
+                options.onFoldAll?.();
+                // Unfold current function
+                options.onUnfoldLines?.(currentFn.startLine, currentFn.endLine);
+            }
+        }
+    });
+    return commands;
+}
+/**
+ * Register semantic fold commands with the global registry
+ */
+export function registerSemanticFoldCommands(editorState, options) {
+    const registry = getCommandRegistry();
+    const commands = createSemanticFoldCommands(editorState, options);
+    return registry.registerMany(commands);
+}

package/dist/components/editor/core/complexity-analyzer.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Cognitive Complexity Analyzer
+ *
+ * Analyzes code complexity in real-time to help developers understand
+ * cognitive load and identify areas that may benefit from refactoring.
+ *
+ * Based on cognitive complexity research and common code quality metrics.
+ */
+import type { Line } from './state';
+/**
+ * Complexity factors for a code region
+ */
+export interface ComplexityFactors {
+    /** Maximum nesting depth (if/for/while/try) */
+    nestingDepth: number;
+    /** Number of branching statements (if/else/switch/case/ternary) */
+    branchingFactor: number;
+    /** Total line count */
+    lineCount: number;
+    /** Number of unique identifiers */
+    identifierCount: number;
+    /** Number of function calls */
+    callCount: number;
+}
+/**
+ * A region of code with its complexity analysis
+ */
+export interface ComplexityRegion {
+    /** Start line (0-based) */
+    startLine: number;
+    /** End line (0-based) */
+    endLine: number;
+    /** Complexity score (0-100) */
+    score: number;
+    /** Individual factors */
+    factors: ComplexityFactors;
+    /** Suggested improvement if score is high */
+    suggestion?: string;
+    /** Region type */
+    type: 'function' | 'class' | 'block' | 'file';
+    /** Region name if identifiable */
+    name?: string;
+}
+/**
+ * Overall complexity metrics for a document
+ */
+export interface ComplexityMetrics {
+    /** Overall complexity score (0-100) */
+    overall: number;
+    /** Complexity level for display */
+    level: 'low' | 'medium' | 'high' | 'critical';
+    /** Per-region breakdown */
+    regions: ComplexityRegion[];
+    /** Lines that exceed threshold */
+    hotspots: number[];
+}
+/**
+ * Complexity Analyzer class
+ */
+export declare class ComplexityAnalyzer {
+    private cache;
+    private cacheKey;
+    /**
+     * Analyze complexity of the given lines
+     */
+    analyze(lines: readonly Line[], language?: string): ComplexityMetrics;
+    /**
+     * Get complexity for a specific line
+     */
+    getLineComplexity(metrics: ComplexityMetrics, line: number): number;
+    /**
+     * Check if a line is a hotspot
+     */
+    isHotspot(metrics: ComplexityMetrics, line: number): boolean;
+    /**
+     * Compute a cache key from all line content using a fast hash
+     */
+    private computeCacheKey;
+    /**
+     * Identify code regions (functions, classes, blocks)
+     *
+     * Uses brace-depth tracking to correctly handle inline braces
+     * (object literals, destructuring) that don't represent new blocks.
+     */
+    private identifyRegions;
+    /**
+     * Check if a `{` at position `ch` is the opening brace of a function/class definition
+     */
+    private isDefOpeningBrace;
+    /**
+     * Analyze a specific region
+     */
+    private analyzeRegion;
+    /**
+     * Calculate complexity factors for a range of lines
+     */
+    private calculateFactors;
+    /**
+     * Calculate complexity score from factors
+     */
+    private calculateScore;
+    /**
+     * Get suggestion based on factors
+     */
+    private getSuggestion;
+    /**
+     * Find hotspot lines (lines in high-complexity regions)
+     */
+    private findHotspots;
+    /**
+     * Calculate overall complexity
+     */
+    private calculateOverall;
+    /**
+     * Get complexity level from score
+     */
+    private getLevel;
+}
+/**
+ * Create a new complexity analyzer
+ */
+export declare function createComplexityAnalyzer(): ComplexityAnalyzer;
+export declare function getComplexityAnalyzer(): ComplexityAnalyzer;