@nocturnium/svelte-ide 1.0.0-rc.1

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

@@ -0,0 +1,335 @@
+/**
+ * Diagnostics Manager
+ *
+ * Manages code diagnostics including:
+ * - Errors, warnings, info, hints
+ * - Quick fixes and code actions
+ * - Diagnostic sources (TypeScript, ESLint, etc.)
+ */
+/**
+ * Diagnostics Manager
+ */
+export class DiagnosticsManager {
+    _config = {
+        enabled: true,
+        showInline: true,
+        showGutterIcons: true,
+        showDelay: 500,
+        maxPerFile: 100,
+        severityFilter: ['error', 'warning', 'info', 'hint']
+    };
+    _diagnostics = new Map();
+    _listeners = new Set();
+    _idCounter = 0;
+    /**
+     * Set diagnostics for a file
+     */
+    setDiagnostics(filePath, diagnostics) {
+        const withIds = diagnostics.map((d) => ({
+            ...d,
+            id: `diag-${++this._idCounter}`
+        }));
+        // Limit per file
+        const limited = withIds.slice(0, this._config.maxPerFile);
+        this._diagnostics.set(filePath, limited);
+        this.notify();
+    }
+    /**
+     * Add diagnostics to a file
+     */
+    addDiagnostics(filePath, diagnostics) {
+        const existing = this._diagnostics.get(filePath) || [];
+        const withIds = diagnostics.map((d) => ({
+            ...d,
+            id: `diag-${++this._idCounter}`
+        }));
+        const combined = [...existing, ...withIds].slice(0, this._config.maxPerFile);
+        this._diagnostics.set(filePath, combined);
+        this.notify();
+    }
+    /**
+     * Clear diagnostics for a file
+     */
+    clearDiagnostics(filePath) {
+        this._diagnostics.delete(filePath);
+        this.notify();
+    }
+    /**
+     * Clear all diagnostics
+     */
+    clearAll() {
+        this._diagnostics.clear();
+        this.notify();
+    }
+    /**
+     * Get diagnostics for a file
+     */
+    getDiagnostics(filePath) {
+        const diagnostics = this._diagnostics.get(filePath) || [];
+        return this.filterDiagnostics(diagnostics);
+    }
+    /**
+     * Get all diagnostics
+     */
+    getAllDiagnostics() {
+        const filtered = new Map();
+        for (const [path, diagnostics] of this._diagnostics) {
+            const filteredDiags = this.filterDiagnostics(diagnostics);
+            if (filteredDiags.length > 0) {
+                filtered.set(path, filteredDiags);
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Get diagnostics at a specific position
+     */
+    getDiagnosticsAtPosition(filePath, position) {
+        const diagnostics = this.getDiagnostics(filePath);
+        return diagnostics.filter((d) => this.positionInRange(position, d.range));
+    }
+    /**
+     * Get diagnostics for a line
+     */
+    getDiagnosticsForLine(filePath, line) {
+        const diagnostics = this.getDiagnostics(filePath);
+        return diagnostics.filter((d) => d.range.start.line <= line && d.range.end.line >= line);
+    }
+    /**
+     * Get counts by severity
+     */
+    getCounts(filePath) {
+        const counts = {
+            error: 0,
+            warning: 0,
+            info: 0,
+            hint: 0
+        };
+        const diagnosticsToCount = filePath
+            ? [this.getDiagnostics(filePath)]
+            : [...this.getAllDiagnostics().values()];
+        for (const diagnostics of diagnosticsToCount) {
+            for (const d of diagnostics) {
+                counts[d.severity]++;
+            }
+        }
+        return counts;
+    }
+    /**
+     * Get total count
+     */
+    getTotalCount(filePath) {
+        const counts = this.getCounts(filePath);
+        return counts.error + counts.warning + counts.info + counts.hint;
+    }
+    /**
+     * Check if position is in range
+     */
+    positionInRange(pos, range) {
+        if (pos.line < range.start.line || pos.line > range.end.line) {
+            return false;
+        }
+        if (pos.line === range.start.line && pos.column < range.start.column) {
+            return false;
+        }
+        if (pos.line === range.end.line && pos.column > range.end.column) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Filter diagnostics by config
+     */
+    filterDiagnostics(diagnostics) {
+        if (!this._config.enabled)
+            return [];
+        return diagnostics.filter((d) => this._config.severityFilter.includes(d.severity));
+    }
+    /**
+     * Apply a fix
+     */
+    applyFix(diagnostic, fix) {
+        // Return the edits for the caller to apply
+        return fix.edits;
+    }
+    /**
+     * Get config
+     */
+    get config() {
+        return { ...this._config };
+    }
+    /**
+     * Update config
+     */
+    setConfig(config) {
+        this._config = { ...this._config, ...config };
+        this.notify();
+    }
+    /**
+     * Enable/disable
+     */
+    setEnabled(enabled) {
+        this._config.enabled = enabled;
+        this.notify();
+    }
+    /**
+     * Check if enabled
+     */
+    isEnabled() {
+        return this._config.enabled;
+    }
+    /**
+     * Set severity filter
+     */
+    setSeverityFilter(severities) {
+        this._config.severityFilter = severities;
+        this.notify();
+    }
+    /**
+     * 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() {
+        this._listeners.clear();
+        this._diagnostics.clear();
+    }
+}
+/**
+ * Create a new DiagnosticsManager instance
+ */
+export function createDiagnosticsManager() {
+    return new DiagnosticsManager();
+}
+/**
+ * Get severity icon
+ */
+export function getSeverityIcon(severity) {
+    switch (severity) {
+        case 'error':
+            return '✕';
+        case 'warning':
+            return '⚠';
+        case 'info':
+            return 'ℹ';
+        case 'hint':
+            return '💡';
+    }
+}
+/**
+ * Get severity color
+ */
+export function getSeverityColor(severity) {
+    switch (severity) {
+        case 'error':
+            return '#f44747';
+        case 'warning':
+            return '#ff8c00';
+        case 'info':
+            return '#3794ff';
+        case 'hint':
+            return '#6c6c6c';
+    }
+}
+/**
+ * Get severity label
+ */
+export function getSeverityLabel(severity) {
+    switch (severity) {
+        case 'error':
+            return 'Error';
+        case 'warning':
+            return 'Warning';
+        case 'info':
+            return 'Info';
+        case 'hint':
+            return 'Hint';
+    }
+}
+/**
+ * Sort diagnostics by severity then line
+ */
+export function sortDiagnostics(diagnostics) {
+    const severityOrder = {
+        error: 0,
+        warning: 1,
+        info: 2,
+        hint: 3
+    };
+    return [...diagnostics].sort((a, b) => {
+        const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
+        if (severityDiff !== 0)
+            return severityDiff;
+        return a.range.start.line - b.range.start.line;
+    });
+}
+/**
+ * Generate mock diagnostics for testing
+ */
+export function generateMockDiagnostics(lineCount) {
+    const diagnostics = [];
+    const sources = ['typescript', 'eslint', 'prettier'];
+    const severities = ['error', 'warning', 'info', 'hint'];
+    const errorMessages = [
+        { code: 'TS2322', message: "Type 'string' is not assignable to type 'number'" },
+        { code: 'TS2339', message: "Property 'foo' does not exist on type 'Bar'" },
+        { code: 'TS2304', message: "Cannot find name 'undefined_var'" },
+        { code: 'TS7006', message: "Parameter 'x' implicitly has an 'any' type" }
+    ];
+    const warningMessages = [
+        { code: 'no-unused-vars', message: "'x' is defined but never used" },
+        { code: 'prefer-const', message: "'let' can be replaced with 'const'" },
+        { code: 'no-console', message: 'Unexpected console statement' }
+    ];
+    // Generate ~10% of lines with diagnostics
+    const numDiagnostics = Math.floor(lineCount * 0.1);
+    for (let i = 0; i < numDiagnostics; i++) {
+        const line = Math.floor(Math.random() * lineCount);
+        const severity = severities[Math.floor(Math.random() * severities.length)];
+        const source = sources[Math.floor(Math.random() * sources.length)];
+        let messageInfo;
+        if (severity === 'error') {
+            messageInfo = errorMessages[Math.floor(Math.random() * errorMessages.length)];
+        }
+        else if (severity === 'warning') {
+            messageInfo = warningMessages[Math.floor(Math.random() * warningMessages.length)];
+        }
+        else {
+            messageInfo = { code: 'info', message: 'Consider refactoring this code' };
+        }
+        diagnostics.push({
+            id: `mock-${i}`,
+            range: {
+                start: { line, column: Math.floor(Math.random() * 20) },
+                end: { line, column: Math.floor(Math.random() * 20) + 20 }
+            },
+            severity,
+            message: messageInfo.message,
+            source,
+            code: messageInfo.code,
+            fixes: severity === 'error' || severity === 'warning'
+                ? [
+                    {
+                        title: `Fix: ${messageInfo.message.slice(0, 30)}...`,
+                        isPreferred: true,
+                        edits: []
+                    }
+                ]
+                : undefined
+        });
+    }
+    return sortDiagnostics(diagnostics);
+}

package/dist/components/editor/core/echo-cursor.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Echo Cursor Manager
+ *
+ * Implements "Echo Mode" where your cursor leaves a trail that replays
+ * keystrokes with a configurable delay. Type in one place, and edits
+ * propagate to echo locations with visible animation.
+ */
+import type { Position } from './state';
+/**
+ * Keystroke event for replay
+ */
+export interface KeystrokeEvent {
+    /** Event ID */
+    id: string;
+    /** Timestamp when recorded */
+    timestamp: number;
+    /** Type of keystroke */
+    type: 'insert' | 'delete' | 'move' | 'newline' | 'tab';
+    /** Data for the keystroke */
+    data: {
+        /** Text inserted (for insert type) */
+        text?: string;
+        /** Direction for delete */
+        direction?: 'forward' | 'backward';
+        /** Count for delete */
+        count?: number;
+        /** New position for move */
+        position?: Position;
+    };
+}
+/**
+ * Echo cursor definition
+ */
+export interface EchoCursor {
+    /** Unique ID */
+    id: string;
+    /** Current position */
+    position: Position;
+    /** Delay in ms before replaying keystrokes */
+    delayMs: number;
+    /** Color for visualization */
+    color: string;
+    /** Whether this echo is active */
+    active: boolean;
+    /** Current replay position in the keystroke buffer */
+    replayIndex: number;
+    /** Whether currently animating a keystroke */
+    isReplaying: boolean;
+    /** Label for display */
+    label?: string;
+}
+/**
+ * Echo mode state
+ */
+export interface EchoModeState {
+    /** Whether echo mode is enabled */
+    enabled: boolean;
+    /** All echo cursors */
+    echoCursors: EchoCursor[];
+    /** Keystroke buffer */
+    keystrokeBuffer: KeystrokeEvent[];
+    /** Default delay for new echoes */
+    defaultDelay: number;
+}
+/**
+ * Echo cursor event types
+ */
+export type EchoCursorEvent = {
+    type: 'echo-added';
+    cursor: EchoCursor;
+} | {
+    type: 'echo-removed';
+    cursorId: string;
+} | {
+    type: 'keystroke-recorded';
+    event: KeystrokeEvent;
+} | {
+    type: 'replay-started';
+    cursorId: string;
+    keystroke: KeystrokeEvent;
+} | {
+    type: 'replay-completed';
+    cursorId: string;
+    keystroke: KeystrokeEvent;
+} | {
+    type: 'mode-changed';
+    enabled: boolean;
+};
+/**
+ * Echo cursor configuration
+ */
+export interface EchoCursorConfig {
+    /** Default delay in ms (default: 150) */
+    defaultDelay: number;
+    /** Maximum echo cursors (default: 10) */
+    maxEchoCursors: number;
+    /** Maximum keystroke buffer size (default: 1000) */
+    maxKeystrokeBuffer: number;
+    /** Colors for echo cursors */
+    colors: string[];
+}
+/**
+ * Echo Cursor Manager
+ */
+export declare class EchoCursorManager {
+    private config;
+    private echoCursors;
+    private keystrokeBuffer;
+    private replayTimers;
+    private listeners;
+    private enabled;
+    private colorIndex;
+    constructor(config?: Partial<EchoCursorConfig>);
+    /**
+     * Enable echo mode
+     */
+    enable(): void;
+    /**
+     * Disable echo mode
+     */
+    disable(): void;
+    /**
+     * Toggle echo mode
+     */
+    toggle(): boolean;
+    /**
+     * Check if echo mode is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Add an echo cursor at a position
+     */
+    addEchoPoint(position: Position, options?: {
+        delay?: number;
+        label?: string;
+    }): EchoCursor | null;
+    /**
+     * Remove an echo cursor
+     */
+    removeEcho(id: string): boolean;
+    /**
+     * Clear all echo cursors
+     */
+    clearAllEchoes(): void;
+    /**
+     * Record a keystroke from the primary cursor
+     */
+    recordKeystroke(event: Omit<KeystrokeEvent, 'id' | 'timestamp'>): KeystrokeEvent;
+    /**
+     * Record text insertion
+     */
+    recordInsert(text: string): KeystrokeEvent;
+    /**
+     * Record text deletion
+     */
+    recordDelete(direction: 'forward' | 'backward', count?: number): KeystrokeEvent;
+    /**
+     * Record newline insertion
+     */
+    recordNewline(): KeystrokeEvent;
+    /**
+     * Record tab insertion
+     */
+    recordTab(): KeystrokeEvent;
+    /**
+     * Get all echo cursors
+     */
+    getEchoCursors(): EchoCursor[];
+    /**
+     * Get echo cursor by ID
+     */
+    getEchoCursor(id: string): EchoCursor | undefined;
+    /**
+     * Get keystroke buffer
+     */
+    getKeystrokeBuffer(): readonly KeystrokeEvent[];
+    /**
+     * Update echo cursor position after replay
+     */
+    updateEchoPosition(id: string, position: Position): void;
+    /**
+     * Subscribe to echo cursor events
+     */
+    subscribe(listener: (event: EchoCursorEvent) => void): () => void;
+    /**
+     * Schedule keystroke replay for an echo cursor
+     */
+    private scheduleReplay;
+    /**
+     * Emit event to listeners
+     */
+    private emit;
+}
+/**
+ * Create an echo cursor manager
+ */
+export declare function createEchoCursorManager(config?: Partial<EchoCursorConfig>): EchoCursorManager;
+/**
+ * Get the global echo cursor manager
+ */
+export declare function getEchoCursorManager(): EchoCursorManager;