@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/quick-actions.js

@@ -0,0 +1,427 @@
+/**
+ * Quick Actions (Code Actions) Manager
+ *
+ * Provides contextual code actions like:
+ * - Quick fixes for errors/warnings
+ * - Refactoring operations
+ * - Code generation
+ * - Import suggestions
+ */
+/**
+ * Quick Actions Manager
+ */
+export class QuickActionsManager {
+    _config = {
+        enabled: true,
+        showLightbulb: true,
+        autoShow: true,
+        showDelay: 300
+    };
+    _providers = new Map();
+    _currentActions = [];
+    _currentContext = null;
+    _listeners = new Set();
+    _showTimeout = null;
+    constructor() {
+        // Register built-in providers
+        this.registerBuiltinProviders();
+    }
+    /**
+     * Register built-in action providers
+     */
+    registerBuiltinProviders() {
+        // Quick fix provider for common issues
+        this.registerProvider('quickfix', (ctx) => {
+            const actions = [];
+            // Fix for unused variables
+            if (ctx.lineContent.includes('const ') || ctx.lineContent.includes('let ')) {
+                const match = ctx.lineContent.match(/(?:const|let)\s+(\w+)/);
+                if (match) {
+                    actions.push({
+                        id: `remove-unused-${match[1]}`,
+                        title: `Remove unused variable '${match[1]}'`,
+                        kind: 'quickfix',
+                        description: 'Remove the declaration of unused variable',
+                        edit: {
+                            changes: [{
+                                    range: {
+                                        start: { line: ctx.position.line, column: 0 },
+                                        end: { line: ctx.position.line + 1, column: 0 }
+                                    },
+                                    newText: ''
+                                }]
+                        }
+                    });
+                }
+            }
+            // Add missing semicolon
+            if (!ctx.lineContent.trim().endsWith(';') &&
+                !ctx.lineContent.trim().endsWith('{') &&
+                !ctx.lineContent.trim().endsWith('}') &&
+                !ctx.lineContent.trim().endsWith(',') &&
+                ctx.lineContent.trim().length > 0) {
+                actions.push({
+                    id: 'add-semicolon',
+                    title: 'Add missing semicolon',
+                    kind: 'quickfix',
+                    isPreferred: true,
+                    edit: {
+                        changes: [{
+                                range: {
+                                    start: { line: ctx.position.line, column: ctx.lineContent.trimEnd().length },
+                                    end: { line: ctx.position.line, column: ctx.lineContent.trimEnd().length }
+                                },
+                                newText: ';'
+                            }]
+                    }
+                });
+            }
+            return actions;
+        });
+        // Refactoring provider
+        this.registerProvider('refactor', (ctx) => {
+            const actions = [];
+            // Extract to variable
+            if (ctx.selectedText && ctx.selectedText.length > 0) {
+                actions.push({
+                    id: 'extract-variable',
+                    title: 'Extract to variable',
+                    kind: 'refactor.extract',
+                    shortcut: 'Ctrl+Alt+V',
+                    command: {
+                        command: 'refactor.extractVariable',
+                        title: 'Extract Variable',
+                        arguments: [ctx.selection, ctx.selectedText]
+                    }
+                });
+                // Extract to function
+                if (ctx.selectedText.includes('\n') || ctx.selectedText.length > 50) {
+                    actions.push({
+                        id: 'extract-function',
+                        title: 'Extract to function',
+                        kind: 'refactor.extract',
+                        shortcut: 'Ctrl+Alt+M',
+                        command: {
+                            command: 'refactor.extractFunction',
+                            title: 'Extract Function',
+                            arguments: [ctx.selection, ctx.selectedText]
+                        }
+                    });
+                }
+            }
+            // Rename symbol
+            const wordMatch = ctx.lineContent.substring(0, ctx.position.column).match(/\w+$/);
+            if (wordMatch) {
+                actions.push({
+                    id: 'rename-symbol',
+                    title: `Rename '${wordMatch[0]}'`,
+                    kind: 'refactor.rename',
+                    shortcut: 'F2',
+                    command: {
+                        command: 'refactor.rename',
+                        title: 'Rename Symbol',
+                        arguments: [ctx.position, wordMatch[0]]
+                    }
+                });
+            }
+            // Convert to arrow function
+            if (ctx.lineContent.includes('function ')) {
+                actions.push({
+                    id: 'convert-to-arrow',
+                    title: 'Convert to arrow function',
+                    kind: 'refactor',
+                    description: 'Convert function declaration to arrow function expression'
+                });
+            }
+            // Convert to template literal
+            if (ctx.lineContent.includes(' + ') && (ctx.lineContent.includes('"') || ctx.lineContent.includes("'"))) {
+                actions.push({
+                    id: 'convert-to-template',
+                    title: 'Convert to template literal',
+                    kind: 'refactor',
+                    description: 'Convert string concatenation to template literal'
+                });
+            }
+            return actions;
+        });
+        // Source actions provider
+        this.registerProvider('source', (ctx) => {
+            const actions = [];
+            // Organize imports
+            if (ctx.lineContent.includes('import ') || ctx.position.line < 20) {
+                actions.push({
+                    id: 'organize-imports',
+                    title: 'Organize imports',
+                    kind: 'source.organizeImports',
+                    shortcut: 'Shift+Alt+O',
+                    command: {
+                        command: 'source.organizeImports',
+                        title: 'Organize Imports'
+                    }
+                });
+            }
+            // Fix all auto-fixable issues
+            actions.push({
+                id: 'fix-all',
+                title: 'Fix all auto-fixable problems',
+                kind: 'source.fixAll',
+                command: {
+                    command: 'source.fixAll',
+                    title: 'Fix All'
+                }
+            });
+            return actions;
+        });
+        // Generate actions provider
+        this.registerProvider('generate', (ctx) => {
+            const actions = [];
+            // Generate JSDoc
+            if (ctx.lineContent.includes('function ') ||
+                ctx.lineContent.includes('const ') ||
+                ctx.lineContent.includes('class ')) {
+                actions.push({
+                    id: 'generate-jsdoc',
+                    title: 'Generate JSDoc comment',
+                    kind: 'generate',
+                    description: 'Add documentation comment above declaration'
+                });
+            }
+            // Generate getter/setter (for class properties)
+            if (ctx.lineContent.includes('private ') || ctx.lineContent.includes('protected ')) {
+                const propMatch = ctx.lineContent.match(/(?:private|protected)\s+(\w+)/);
+                if (propMatch) {
+                    actions.push({
+                        id: 'generate-getter',
+                        title: `Generate getter for '${propMatch[1]}'`,
+                        kind: 'generate'
+                    });
+                    actions.push({
+                        id: 'generate-setter',
+                        title: `Generate setter for '${propMatch[1]}'`,
+                        kind: 'generate'
+                    });
+                }
+            }
+            // Generate constructor
+            if (ctx.lineContent.includes('class ')) {
+                actions.push({
+                    id: 'generate-constructor',
+                    title: 'Generate constructor',
+                    kind: 'generate'
+                });
+            }
+            return actions;
+        });
+    }
+    /**
+     * Register a code action provider
+     */
+    registerProvider(id, provider) {
+        this._providers.set(id, provider);
+        return () => this._providers.delete(id);
+    }
+    /**
+     * Get available actions for context
+     */
+    getActions(context) {
+        if (!this._config.enabled)
+            return [];
+        const actions = [];
+        for (const provider of this._providers.values()) {
+            try {
+                const providerActions = provider(context);
+                actions.push(...providerActions);
+            }
+            catch (e) {
+                console.error('Code action provider error:', e);
+            }
+        }
+        // Sort by kind and preferred status
+        return actions.sort((a, b) => {
+            // Preferred actions first
+            if (a.isPreferred && !b.isPreferred)
+                return -1;
+            if (!a.isPreferred && b.isPreferred)
+                return 1;
+            // Then by kind priority
+            const kindPriority = {
+                'quickfix': 0,
+                'refactor.extract': 1,
+                'refactor.inline': 2,
+                'refactor.rename': 3,
+                'refactor': 4,
+                'source.organizeImports': 5,
+                'source.fixAll': 6,
+                'source': 7,
+                'generate': 8
+            };
+            return (kindPriority[a.kind] ?? 99) - (kindPriority[b.kind] ?? 99);
+        });
+    }
+    /**
+     * Update context and refresh actions
+     */
+    updateContext(context) {
+        if (this._showTimeout) {
+            clearTimeout(this._showTimeout);
+        }
+        if (!this._config.autoShow) {
+            this._currentContext = context;
+            return;
+        }
+        this._showTimeout = setTimeout(() => {
+            this._currentContext = context;
+            this._currentActions = this.getActions(context);
+            this.notify();
+        }, this._config.showDelay);
+    }
+    /**
+     * Force refresh actions
+     */
+    refresh() {
+        if (this._currentContext) {
+            this._currentActions = this.getActions(this._currentContext);
+            this.notify();
+        }
+    }
+    /**
+     * Execute a code action
+     */
+    async executeAction(action) {
+        if (action.disabled) {
+            console.warn('Cannot execute disabled action:', action.disabledReason);
+            return false;
+        }
+        // If action has an edit, apply it
+        if (action.edit) {
+            // The edit would be applied by the editor
+            // Return the edit for the caller to handle
+            return true;
+        }
+        // If action has a command, execute it
+        if (action.command) {
+            // The command would be executed by the editor
+            // Return true to indicate the action was triggered
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get current actions
+     */
+    get currentActions() {
+        return this._currentActions;
+    }
+    /**
+     * Check if actions are available
+     */
+    get hasActions() {
+        return this._currentActions.length > 0;
+    }
+    /**
+     * Get config
+     */
+    get config() {
+        return { ...this._config };
+    }
+    /**
+     * Update config
+     */
+    setConfig(config) {
+        this._config = { ...this._config, ...config };
+        this.notify();
+    }
+    /**
+     * Enable/disable quick actions
+     */
+    setEnabled(enabled) {
+        this._config.enabled = enabled;
+        if (!enabled) {
+            this._currentActions = [];
+        }
+        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();
+        }
+    }
+    /**
+     * Clean up
+     */
+    destroy() {
+        if (this._showTimeout) {
+            clearTimeout(this._showTimeout);
+        }
+        this._listeners.clear();
+        this._providers.clear();
+    }
+}
+/**
+ * Create a new QuickActionsManager instance
+ */
+export function createQuickActionsManager() {
+    return new QuickActionsManager();
+}
+/**
+ * Group actions by kind for display
+ */
+export function groupActionsByKind(actions) {
+    const groups = new Map();
+    for (const action of actions) {
+        // Get the base kind (e.g., "refactor" from "refactor.extract")
+        const baseKind = action.kind.split('.')[0];
+        const kindLabel = getKindLabel(baseKind);
+        if (!groups.has(kindLabel)) {
+            groups.set(kindLabel, []);
+        }
+        groups.get(kindLabel).push(action);
+    }
+    return groups;
+}
+/**
+ * Get display label for action kind
+ */
+export function getKindLabel(kind) {
+    const labels = {
+        'quickfix': 'Quick Fix',
+        'refactor': 'Refactor',
+        'source': 'Source Action',
+        'generate': 'Generate'
+    };
+    const baseKind = kind.split('.')[0];
+    return labels[baseKind] || kind;
+}
+/**
+ * Get icon for action kind
+ */
+export function getKindIcon(kind) {
+    const icons = {
+        'quickfix': '🔧',
+        'refactor': '✨',
+        'refactor.extract': '📤',
+        'refactor.inline': '📥',
+        'refactor.rename': '✏️',
+        'source': '📋',
+        'source.organizeImports': '📦',
+        'source.fixAll': '✅',
+        'generate': '⚡'
+    };
+    return icons[kind] || icons[kind.split('.')[0]] || '💡';
+}

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

@@ -0,0 +1,88 @@
+/**
+ * Search utilities for find and replace functionality
+ */
+import type { Position } from './state';
+export interface SearchMatch {
+    /** Start position of match */
+    start: Position;
+    /** End position of match */
+    end: Position;
+    /** The matched text */
+    text: string;
+    /** Line index (0-based) */
+    line: number;
+    /** Start column in line */
+    startColumn: number;
+    /** End column in line */
+    endColumn: number;
+}
+export interface SearchOptions {
+    /** Case sensitive search */
+    caseSensitive?: boolean;
+    /** Use regular expression */
+    useRegex?: boolean;
+    /** Wrap around when reaching end of document */
+    wrapAround?: boolean;
+}
+export interface SearchState {
+    /** Current search query */
+    query: string;
+    /** Search options */
+    options: SearchOptions;
+    /** All matches in document */
+    matches: SearchMatch[];
+    /** Current match index (0-based) */
+    currentIndex: number;
+}
+/**
+ * Create initial search state
+ */
+export declare function createSearchState(): SearchState;
+/**
+ * Find all matches in content
+ */
+export declare function findAllMatches(lines: readonly {
+    text: string;
+}[], query: string, options?: SearchOptions): SearchMatch[];
+/**
+ * Find the match index closest to a position (at or after)
+ */
+export declare function findMatchIndexAtOrAfter(matches: SearchMatch[], position: Position): number;
+/**
+ * Find the match index closest to a position (at or before)
+ */
+export declare function findMatchIndexAtOrBefore(matches: SearchMatch[], position: Position): number;
+/**
+ * Get next match index (with wrap-around)
+ */
+export declare function getNextMatchIndex(matches: SearchMatch[], currentIndex: number, wrapAround?: boolean): number;
+/**
+ * Get previous match index (with wrap-around)
+ */
+export declare function getPrevMatchIndex(matches: SearchMatch[], currentIndex: number, wrapAround?: boolean): number;
+/**
+ * Replace text at a match position
+ * Returns the new content and adjusted cursor position
+ */
+export declare function replaceMatch(lines: readonly {
+    text: string;
+}[], match: SearchMatch, replacement: string): {
+    newLines: string[];
+    cursorPosition: Position;
+    lengthDiff: number;
+};
+/**
+ * Replace all matches
+ * Returns the new content
+ */
+export declare function replaceAllMatches(lines: readonly {
+    text: string;
+}[], matches: SearchMatch[], replacement: string): string[];
+/**
+ * Check if a position is within a match
+ */
+export declare function isPositionInMatch(position: Position, match: SearchMatch): boolean;
+/**
+ * Find match at exact position (if cursor is inside a match)
+ */
+export declare function findMatchAtPosition(matches: SearchMatch[], position: Position): number;

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

@@ -0,0 +1,192 @@
+/**
+ * Search utilities for find and replace functionality
+ */
+/**
+ * Create initial search state
+ */
+export function createSearchState() {
+    return {
+        query: '',
+        options: {
+            caseSensitive: false,
+            useRegex: false,
+            wrapAround: true
+        },
+        matches: [],
+        currentIndex: -1
+    };
+}
+/**
+ * Find all matches in content
+ */
+export function findAllMatches(lines, query, options = {}) {
+    if (!query)
+        return [];
+    const matches = [];
+    const { caseSensitive = false, useRegex = false } = options;
+    let searchPattern;
+    try {
+        if (useRegex) {
+            searchPattern = new RegExp(query, caseSensitive ? 'g' : 'gi');
+        }
+        else {
+            // Escape regex special characters for literal search
+            const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            searchPattern = new RegExp(escaped, caseSensitive ? 'g' : 'gi');
+        }
+    }
+    catch {
+        // Invalid regex - return empty matches
+        return [];
+    }
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const text = line.text;
+        let match;
+        // Reset lastIndex for each line
+        searchPattern.lastIndex = 0;
+        while ((match = searchPattern.exec(text)) !== null) {
+            const startColumn = match.index;
+            const endColumn = match.index + match[0].length;
+            matches.push({
+                start: { line: lineIndex, column: startColumn },
+                end: { line: lineIndex, column: endColumn },
+                text: match[0],
+                line: lineIndex,
+                startColumn,
+                endColumn
+            });
+            // Prevent infinite loop on zero-width matches
+            if (match[0].length === 0) {
+                searchPattern.lastIndex++;
+            }
+        }
+    }
+    return matches;
+}
+/**
+ * Find the match index closest to a position (at or after)
+ */
+export function findMatchIndexAtOrAfter(matches, position) {
+    if (matches.length === 0)
+        return -1;
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        // Match is at or after position
+        if (match.line > position.line ||
+            (match.line === position.line && match.startColumn >= position.column)) {
+            return i;
+        }
+    }
+    // No match at or after position - wrap to first match
+    return 0;
+}
+/**
+ * Find the match index closest to a position (at or before)
+ */
+export function findMatchIndexAtOrBefore(matches, position) {
+    if (matches.length === 0)
+        return -1;
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const match = matches[i];
+        // Match is at or before position
+        if (match.line < position.line ||
+            (match.line === position.line && match.endColumn <= position.column)) {
+            return i;
+        }
+    }
+    // No match at or before position - wrap to last match
+    return matches.length - 1;
+}
+/**
+ * Get next match index (with wrap-around)
+ */
+export function getNextMatchIndex(matches, currentIndex, wrapAround = true) {
+    if (matches.length === 0)
+        return -1;
+    if (currentIndex < 0)
+        return 0;
+    const next = currentIndex + 1;
+    if (next >= matches.length) {
+        return wrapAround ? 0 : currentIndex;
+    }
+    return next;
+}
+/**
+ * Get previous match index (with wrap-around)
+ */
+export function getPrevMatchIndex(matches, currentIndex, wrapAround = true) {
+    if (matches.length === 0)
+        return -1;
+    if (currentIndex < 0)
+        return matches.length - 1;
+    const prev = currentIndex - 1;
+    if (prev < 0) {
+        return wrapAround ? matches.length - 1 : currentIndex;
+    }
+    return prev;
+}
+/**
+ * Replace text at a match position
+ * Returns the new content and adjusted cursor position
+ */
+export function replaceMatch(lines, match, replacement) {
+    const newLines = lines.map((l) => l.text);
+    const line = newLines[match.line];
+    // Replace the match
+    newLines[match.line] =
+        line.substring(0, match.startColumn) +
+            replacement +
+            line.substring(match.endColumn);
+    const lengthDiff = replacement.length - match.text.length;
+    return {
+        newLines,
+        cursorPosition: {
+            line: match.line,
+            column: match.startColumn + replacement.length
+        },
+        lengthDiff
+    };
+}
+/**
+ * Replace all matches
+ * Returns the new content
+ */
+export function replaceAllMatches(lines, matches, replacement) {
+    if (matches.length === 0)
+        return lines.map((l) => l.text);
+    const newLines = lines.map((l) => l.text);
+    // Process matches in reverse order to maintain correct positions
+    const sortedMatches = [...matches].sort((a, b) => {
+        if (a.line !== b.line)
+            return b.line - a.line;
+        return b.startColumn - a.startColumn;
+    });
+    for (const match of sortedMatches) {
+        const line = newLines[match.line];
+        newLines[match.line] =
+            line.substring(0, match.startColumn) +
+                replacement +
+                line.substring(match.endColumn);
+    }
+    return newLines;
+}
+/**
+ * Check if a position is within a match
+ */
+export function isPositionInMatch(position, match) {
+    if (position.line !== match.line)
+        return false;
+    return position.column >= match.startColumn && position.column < match.endColumn;
+}
+/**
+ * Find match at exact position (if cursor is inside a match)
+ */
+export function findMatchAtPosition(matches, position) {
+    for (let i = 0; i < matches.length; i++) {
+        if (isPositionInMatch(position, matches[i])) {
+            return i;
+        }
+    }
+    return -1;
+}