@nocturnium/svelte-ide 1.0.0-rc.1

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

@@ -0,0 +1,77 @@
+/**
+ * Semantic Analyzer
+ *
+ * Analyzes code to identify semantic regions for intelligent folding.
+ * Unlike syntax-based folding, semantic folding understands code meaning:
+ * - "Collapse all imports"
+ * - "Show only public API"
+ * - "Hide error handling"
+ */
+import type { Line } from './state';
+/**
+ * Semantic categories for code regions
+ */
+export type SemanticCategory = 'imports' | 'exports' | 'types' | 'constants' | 'error-handling' | 'logging' | 'tests' | 'setup' | 'private' | 'public' | 'comments' | 'boilerplate' | 'function' | 'class';
+/**
+ * A semantic region in the code
+ */
+export interface SemanticRegion {
+    /** Category of this region */
+    category: SemanticCategory;
+    /** Start line (0-based) */
+    startLine: number;
+    /** End line (0-based) */
+    endLine: number;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Human-readable label */
+    label?: string;
+    /** Nested regions */
+    children?: SemanticRegion[];
+}
+/**
+ * Semantic Analyzer class
+ */
+export declare class SemanticAnalyzer {
+    private cache;
+    private cacheKey;
+    /**
+     * Analyze lines and return semantic regions
+     */
+    analyze(lines: readonly Line[], language: string): SemanticRegion[];
+    /**
+     * Get regions by category
+     */
+    getByCategory(regions: SemanticRegion[], category: SemanticCategory): SemanticRegion[];
+    /**
+     * Get all categories present in regions
+     */
+    getCategories(regions: SemanticRegion[]): SemanticCategory[];
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+}
+/**
+ * Fold preset configuration
+ */
+export interface FoldPreset {
+    id: string;
+    name: string;
+    description: string;
+    /** Categories to keep visible */
+    show: SemanticCategory[];
+    /** Categories to collapse */
+    hide: SemanticCategory[];
+    /** Icon for UI */
+    icon?: string;
+}
+/**
+ * Default fold presets
+ */
+export declare const DEFAULT_FOLD_PRESETS: FoldPreset[];
+export declare function getSemanticAnalyzer(): SemanticAnalyzer;
+/**
+ * Create new analyzer instance
+ */
+export declare function createSemanticAnalyzer(): SemanticAnalyzer;

package/dist/components/editor/core/semantic-analyzer.js

@@ -0,0 +1,424 @@
+/**
+ * Semantic Analyzer
+ *
+ * Analyzes code to identify semantic regions for intelligent folding.
+ * Unlike syntax-based folding, semantic folding understands code meaning:
+ * - "Collapse all imports"
+ * - "Show only public API"
+ * - "Hide error handling"
+ */
+/**
+ * Pattern definitions for JavaScript/TypeScript
+ */
+const JAVASCRIPT_PATTERNS = new Map([
+    [
+        'imports',
+        {
+            startPattern: /^import\s|^const\s+\w+\s*=\s*require\s*\(/,
+            endPattern: /^(?!import|const\s+\w+\s*=\s*require)/,
+            multiline: true,
+            getLabel: () => 'Import statements'
+        }
+    ],
+    [
+        'exports',
+        {
+            startPattern: /^export\s+(default\s+)?(function|class|const|let|var|interface|type)/,
+            blockBased: true,
+            getLabel: (m) => `Export: ${m[2] || 'default'}`
+        }
+    ],
+    [
+        'types',
+        {
+            startPattern: /^(export\s+)?(interface|type)\s+(\w+)/,
+            blockBased: true,
+            getLabel: (m) => `Type: ${m[3]}`
+        }
+    ],
+    [
+        'error-handling',
+        {
+            startPattern: /\btry\s*\{/,
+            blockBased: true,
+            getLabel: () => 'Error handling'
+        }
+    ],
+    [
+        'logging',
+        {
+            linePattern: /\b(console|logger)\.\w+\s*\(/,
+            getLabel: () => 'Logging'
+        }
+    ],
+    [
+        'tests',
+        {
+            startPattern: /\b(describe|it|test|beforeEach|afterEach|beforeAll|afterAll)\s*\(/,
+            blockBased: true,
+            getLabel: (m) => `Test: ${m[1]}`
+        }
+    ],
+    [
+        'comments',
+        {
+            startPattern: /^\s*\/\*\*/,
+            endPattern: /\*\/\s*$/,
+            multiline: true,
+            getLabel: () => 'Documentation'
+        }
+    ],
+    [
+        'function',
+        {
+            startPattern: /^(export\s+)?(async\s+)?function\s+(\w+)|^const\s+(\w+)\s*=\s*(async\s*)?\([^)]*\)\s*=>/,
+            blockBased: true,
+            getLabel: (m) => `Function: ${m[3] || m[4] || 'anonymous'}`
+        }
+    ],
+    [
+        'class',
+        {
+            startPattern: /^(export\s+)?class\s+(\w+)/,
+            blockBased: true,
+            getLabel: (m) => `Class: ${m[2]}`
+        }
+    ],
+    [
+        'private',
+        {
+            startPattern: /^\s*(private|#)\s*(\w+)|^\s*_\w+\s*[=(:]/,
+            blockBased: true,
+            getLabel: () => 'Private member'
+        }
+    ],
+    [
+        'constants',
+        {
+            linePattern: /^(export\s+)?const\s+[A-Z][A-Z0-9_]+\s*=/,
+            getLabel: () => 'Constants'
+        }
+    ]
+]);
+/**
+ * Pattern definitions for Python
+ */
+const PYTHON_PATTERNS = new Map([
+    [
+        'imports',
+        {
+            startPattern: /^(import\s|from\s+\w+\s+import)/,
+            endPattern: /^(?!import|from\s)/,
+            multiline: true,
+            getLabel: () => 'Import statements'
+        }
+    ],
+    [
+        'function',
+        {
+            startPattern: /^(async\s+)?def\s+(\w+)/,
+            blockBased: true,
+            getLabel: (m) => `Function: ${m[2]}`
+        }
+    ],
+    [
+        'class',
+        {
+            startPattern: /^class\s+(\w+)/,
+            blockBased: true,
+            getLabel: (m) => `Class: ${m[1]}`
+        }
+    ],
+    [
+        'tests',
+        {
+            startPattern: /^def\s+test_\w+|^class\s+Test\w+/,
+            blockBased: true,
+            getLabel: () => 'Test'
+        }
+    ],
+    [
+        'comments',
+        {
+            startPattern: /^\s*"""/,
+            endPattern: /"""\s*$/,
+            multiline: true,
+            getLabel: () => 'Docstring'
+        }
+    ],
+    [
+        'error-handling',
+        {
+            startPattern: /^\s*try\s*:/,
+            blockBased: true,
+            getLabel: () => 'Error handling'
+        }
+    ],
+    [
+        'private',
+        {
+            startPattern: /^\s*def\s+_\w+|^\s*_\w+\s*=/,
+            blockBased: true,
+            getLabel: () => 'Private member'
+        }
+    ]
+]);
+/**
+ * Default patterns for unknown languages
+ */
+const DEFAULT_PATTERNS = new Map([
+    [
+        'comments',
+        {
+            startPattern: /^\s*\/\*|^\s*#|^\s*\/\//,
+            getLabel: () => 'Comment'
+        }
+    ],
+    [
+        'function',
+        {
+            startPattern: /function\s+\w+|def\s+\w+|fn\s+\w+/,
+            blockBased: true,
+            getLabel: () => 'Function'
+        }
+    ]
+]);
+/**
+ * Get patterns for a language
+ */
+function getPatternsForLanguage(language) {
+    const normalized = language.toLowerCase();
+    if (normalized === 'javascript' || normalized === 'typescript' || normalized === 'svelte') {
+        return JAVASCRIPT_PATTERNS;
+    }
+    if (normalized === 'python') {
+        return PYTHON_PATTERNS;
+    }
+    return DEFAULT_PATTERNS;
+}
+/**
+ * Semantic Analyzer class
+ */
+export class SemanticAnalyzer {
+    cache = new Map();
+    cacheKey = '';
+    /**
+     * Analyze lines and return semantic regions
+     */
+    analyze(lines, language) {
+        // Simple cache check
+        const key = `${language}:${lines.length}:${lines[0]?.text ?? ''}`;
+        if (key === this.cacheKey && this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const patterns = getPatternsForLanguage(language);
+        const regions = [];
+        // Track block depth for block-based patterns
+        const blockStack = [];
+        let currentDepth = 0;
+        // Track multiline regions
+        const multilineRegions = new Map();
+        for (let i = 0; i < lines.length; i++) {
+            const text = lines[i].text;
+            // Count braces for depth tracking
+            const opens = (text.match(/\{/g) || []).length;
+            const closes = (text.match(/\}/g) || []).length;
+            // Check for pattern matches
+            for (const [category, config] of patterns) {
+                // Line patterns (single line matches)
+                if (config.linePattern) {
+                    if (config.linePattern.test(text)) {
+                        // Find or create a contiguous region
+                        const lastRegion = regions.find((r) => r.category === category &&
+                            r.endLine === i - 1 &&
+                            !config.blockBased);
+                        if (lastRegion) {
+                            lastRegion.endLine = i;
+                        }
+                        else {
+                            regions.push({
+                                category,
+                                startLine: i,
+                                endLine: i,
+                                confidence: 0.9,
+                                label: config.getLabel?.(text.match(config.linePattern)) ?? category
+                            });
+                        }
+                    }
+                }
+                // Multiline patterns
+                if (config.multiline && config.startPattern && config.endPattern) {
+                    if (!multilineRegions.has(category) && config.startPattern.test(text)) {
+                        multilineRegions.set(category, {
+                            startLine: i,
+                            label: config.getLabel?.(text.match(config.startPattern))
+                        });
+                    }
+                    else if (multilineRegions.has(category) && config.endPattern.test(text)) {
+                        const start = multilineRegions.get(category);
+                        regions.push({
+                            category,
+                            startLine: start.startLine,
+                            endLine: i,
+                            confidence: 0.85,
+                            label: start.label ?? category
+                        });
+                        multilineRegions.delete(category);
+                    }
+                }
+                // Multiline without explicit end (ends when pattern stops matching)
+                if (config.multiline && config.startPattern && !config.endPattern) {
+                    if (!multilineRegions.has(category) && config.startPattern.test(text)) {
+                        multilineRegions.set(category, {
+                            startLine: i,
+                            label: config.getLabel?.(text.match(config.startPattern))
+                        });
+                    }
+                    else if (multilineRegions.has(category)) {
+                        if (!config.startPattern.test(text) && text.trim() !== '') {
+                            // End the region
+                            const start = multilineRegions.get(category);
+                            regions.push({
+                                category,
+                                startLine: start.startLine,
+                                endLine: i - 1,
+                                confidence: 0.8,
+                                label: start.label ?? category
+                            });
+                            multilineRegions.delete(category);
+                        }
+                    }
+                }
+                // Block-based patterns
+                if (config.blockBased && config.startPattern) {
+                    const match = text.match(config.startPattern);
+                    if (match && opens > 0) {
+                        blockStack.push({
+                            category,
+                            startLine: i,
+                            depth: currentDepth + opens,
+                            label: config.getLabel?.(match)
+                        });
+                    }
+                }
+            }
+            // Update depth
+            currentDepth += opens - closes;
+            // Check if any blocks closed
+            while (blockStack.length > 0 && currentDepth < blockStack[blockStack.length - 1].depth) {
+                const block = blockStack.pop();
+                regions.push({
+                    category: block.category,
+                    startLine: block.startLine,
+                    endLine: i,
+                    confidence: 0.9,
+                    label: block.label
+                });
+            }
+        }
+        // Close any remaining multiline regions
+        for (const [category, start] of multilineRegions) {
+            regions.push({
+                category,
+                startLine: start.startLine,
+                endLine: lines.length - 1,
+                confidence: 0.7,
+                label: start.label ?? category
+            });
+        }
+        // Sort by start line
+        regions.sort((a, b) => a.startLine - b.startLine);
+        // Cache result
+        this.cacheKey = key;
+        this.cache.set(key, regions);
+        return regions;
+    }
+    /**
+     * Get regions by category
+     */
+    getByCategory(regions, category) {
+        return regions.filter((r) => r.category === category);
+    }
+    /**
+     * Get all categories present in regions
+     */
+    getCategories(regions) {
+        return [...new Set(regions.map((r) => r.category))];
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.cache.clear();
+        this.cacheKey = '';
+    }
+}
+/**
+ * Default fold presets
+ */
+export const DEFAULT_FOLD_PRESETS = [
+    {
+        id: 'code-review',
+        name: 'Code Review',
+        description: 'Hide tests, show implementation',
+        show: ['exports', 'public', 'function', 'class'],
+        hide: ['tests', 'setup', 'imports', 'comments'],
+        icon: '\u{1F50D}'
+    },
+    {
+        id: 'api-surface',
+        name: 'API Surface',
+        description: 'Show only public interface',
+        show: ['exports', 'types', 'public'],
+        hide: ['private', 'tests', 'error-handling', 'logging', 'comments'],
+        icon: '\u{1F4E4}'
+    },
+    {
+        id: 'debugging',
+        name: 'Debugging',
+        description: 'Show error handling and logging',
+        show: ['error-handling', 'logging'],
+        hide: ['comments', 'types', 'tests'],
+        icon: '\u{1F41B}'
+    },
+    {
+        id: 'tests-only',
+        name: 'Tests Only',
+        description: 'Show only test code',
+        show: ['tests', 'setup'],
+        hide: ['imports', 'comments', 'types'],
+        icon: '\u{1F9EA}'
+    },
+    {
+        id: 'minimal',
+        name: 'Minimal View',
+        description: 'Hide boilerplate and comments',
+        show: ['function', 'class', 'exports'],
+        hide: ['imports', 'comments', 'boilerplate', 'logging'],
+        icon: '\u{1F4CB}'
+    },
+    {
+        id: 'documentation',
+        name: 'Documentation',
+        description: 'Show types and comments',
+        show: ['types', 'comments', 'exports'],
+        hide: ['private', 'tests', 'error-handling', 'logging'],
+        icon: '\u{1F4D6}'
+    }
+];
+/**
+ * Singleton instance
+ */
+let defaultAnalyzer = null;
+export function getSemanticAnalyzer() {
+    if (!defaultAnalyzer) {
+        defaultAnalyzer = new SemanticAnalyzer();
+    }
+    return defaultAnalyzer;
+}
+/**
+ * Create new analyzer instance
+ */
+export function createSemanticAnalyzer() {
+    return new SemanticAnalyzer();
+}

package/dist/components/editor/core/snippet-manager.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Snippet Manager
+ *
+ * Manages code snippets with tab stops, placeholders, and variable expansion.
+ * Supports VS Code-style snippet syntax.
+ */
+import type { Position } from './state';
+/**
+ * Snippet definition
+ */
+export interface Snippet {
+    /** Unique ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Trigger prefix (what user types to activate) */
+    prefix: string;
+    /** Snippet body (with placeholders) */
+    body: string;
+    /** Description */
+    description: string;
+    /** Languages this snippet applies to (empty = all) */
+    languages: string[];
+    /** Category for organization */
+    category: string;
+    /** Whether this is a user-defined snippet */
+    isUserDefined: boolean;
+    /** Usage count for sorting */
+    usageCount: number;
+    /** Last used timestamp */
+    lastUsed: Date | null;
+}
+/**
+ * Parsed placeholder/tab stop
+ */
+export interface SnippetTabStop {
+    /** Tab stop index (0 = final position, 1+ = visit order) */
+    index: number;
+    /** Start offset in expanded text */
+    start: number;
+    /** End offset in expanded text */
+    end: number;
+    /** Placeholder text (if any) */
+    placeholder: string;
+    /** Choices (if this is a choice placeholder) */
+    choices?: string[];
+    /** Variable name (if this is a variable) */
+    variable?: string;
+}
+/**
+ * Expanded snippet ready for insertion
+ */
+export interface ExpandedSnippet {
+    /** Expanded text */
+    text: string;
+    /** Tab stops in order */
+    tabStops: SnippetTabStop[];
+    /** Current tab stop index */
+    currentTabStop: number;
+}
+/**
+ * Snippet session (active snippet editing)
+ */
+export interface SnippetSession {
+    /** Session ID */
+    id: string;
+    /** Snippet being edited */
+    snippet: Snippet;
+    /** Expanded content */
+    expanded: ExpandedSnippet;
+    /** Start position in document */
+    startPosition: Position;
+    /** Whether session is active */
+    isActive: boolean;
+}
+/**
+ * Snippet manager configuration
+ */
+export interface SnippetManagerConfig {
+    /** Maximum number of user snippets */
+    maxUserSnippets: number;
+    /** Built-in snippets */
+    builtInSnippets: Snippet[];
+}
+/**
+ * Snippet Manager
+ */
+export declare class SnippetManager {
+    private config;
+    private snippets;
+    private userSnippets;
+    private activeSession;
+    private listeners;
+    constructor(config?: Partial<SnippetManagerConfig>);
+    /**
+     * Load built-in snippets
+     */
+    private loadBuiltInSnippets;
+    /**
+     * Add a user-defined snippet
+     */
+    addSnippet(snippet: Omit<Snippet, 'id' | 'isUserDefined' | 'usageCount' | 'lastUsed'>): Snippet;
+    /**
+     * Update a user-defined snippet
+     */
+    updateSnippet(id: string, updates: Partial<Omit<Snippet, 'id' | 'isUserDefined'>>): boolean;
+    /**
+     * Delete a user-defined snippet
+     */
+    deleteSnippet(id: string): boolean;
+    /**
+     * Get all snippets for a language
+     */
+    getSnippetsForLanguage(language: string): Snippet[];
+    /**
+     * Find snippets matching a prefix
+     */
+    findByPrefix(prefix: string, language: string): Snippet[];
+    /**
+     * Get snippet by ID
+     */
+    getSnippet(id: string): Snippet | undefined;
+    /**
+     * Expand a snippet body with variables
+     */
+    expand(snippet: Snippet, variables?: Record<string, string>): ExpandedSnippet;
+    /**
+     * Start a snippet session
+     */
+    startSession(snippet: Snippet, startPosition: Position, variables?: Record<string, string>): SnippetSession;
+    /**
+     * Move to next tab stop
+     */
+    nextTabStop(): SnippetTabStop | null;
+    /**
+     * Move to previous tab stop
+     */
+    prevTabStop(): SnippetTabStop | null;
+    /**
+     * Get current tab stop
+     */
+    getCurrentTabStop(): SnippetTabStop | null;
+    /**
+     * End the current snippet session
+     */
+    endSession(): void;
+    /**
+     * Check if a session is active
+     */
+    hasActiveSession(): boolean;
+    /**
+     * Get active session
+     */
+    getActiveSession(): SnippetSession | null;
+    /**
+     * Get all categories
+     */
+    getCategories(language?: string): string[];
+    /**
+     * Export user snippets as JSON
+     */
+    exportUserSnippets(): string;
+    /**
+     * Import user snippets from JSON
+     */
+    importUserSnippets(json: string): number;
+    /**
+     * Subscribe to events
+     */
+    subscribe(listener: (event: SnippetEvent) => void): () => void;
+    /**
+     * Emit event
+     */
+    private emit;
+}
+/**
+ * Snippet events
+ */
+export type SnippetEvent = {
+    type: 'snippet-added';
+    snippet: Snippet;
+} | {
+    type: 'snippet-updated';
+    snippet: Snippet;
+} | {
+    type: 'snippet-deleted';
+    snippetId: string;
+} | {
+    type: 'session-started';
+    session: SnippetSession;
+} | {
+    type: 'session-ended';
+    session: SnippetSession;
+} | {
+    type: 'tabstop-changed';
+    tabStop: SnippetTabStop;
+    session: SnippetSession;
+};
+/**
+ * Create a snippet manager
+ */
+export declare function createSnippetManager(config?: Partial<SnippetManagerConfig>): SnippetManager;