@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/components/editor/core/crdt-binding.js

@@ -0,0 +1,286 @@
+/**
+ * CRDT binding for the custom editor
+ *
+ * This module provides integration between the custom editor state
+ * and Yjs CRDT for real-time collaborative editing.
+ */
+import * as Y from 'yjs';
+/**
+ * CRDT binding class that syncs editor state with Yjs
+ */
+export class CRDTBinding {
+    doc;
+    text;
+    editorState;
+    isUpdating = false;
+    isDestroyed = false;
+    cleanupFns = [];
+    // Store observer reference for guaranteed cleanup
+    textObserver = null;
+    constructor(config) {
+        this.doc = config.doc;
+        this.text = config.doc.getText(config.textName ?? 'content');
+        this.editorState = config.editorState;
+        this.setupBindings();
+    }
+    /**
+     * Set up bidirectional bindings
+     */
+    setupBindings() {
+        // Sync initial content
+        this.syncFromCRDT();
+        // Listen for CRDT changes - use bound method for reliable cleanup
+        this.textObserver = (event) => {
+            if (this.isDestroyed || this.isUpdating)
+                return;
+            this.handleCRDTChange(event);
+        };
+        this.text.observe(this.textObserver);
+        this.cleanupFns.push(() => {
+            if (this.textObserver) {
+                this.text.unobserve(this.textObserver);
+                this.textObserver = null;
+            }
+        });
+        // Listen for local editor changes
+        const unsubscribe = this.editorState.onContentChange((event) => {
+            if (this.isDestroyed || this.isUpdating)
+                return;
+            this.handleLocalChange(event);
+        });
+        this.cleanupFns.push(unsubscribe);
+    }
+    /**
+     * Sync content from CRDT to editor
+     */
+    syncFromCRDT() {
+        this.isUpdating = true;
+        try {
+            const content = this.text.toString();
+            this.editorState.setContent(content);
+        }
+        finally {
+            this.isUpdating = false;
+        }
+    }
+    /**
+     * Handle changes from CRDT
+     * Uses Yjs relative positions for accurate cursor preservation during concurrent edits
+     */
+    handleCRDTChange(event) {
+        this.isUpdating = true;
+        try {
+            // Capture current selection as relative positions BEFORE applying changes
+            // Relative positions survive structural changes to the document
+            const currentSelection = this.editorState.selection;
+            const anchorIndex = this.positionToIndex(currentSelection.anchor);
+            const headIndex = this.positionToIndex(currentSelection.head);
+            // Create Yjs relative positions (these track position relative to surrounding content)
+            const anchorRelPos = Y.createRelativePositionFromTypeIndex(this.text, anchorIndex);
+            const headRelPos = Y.createRelativePositionFromTypeIndex(this.text, headIndex);
+            // Get new content
+            const content = this.text.toString();
+            // Resolve relative positions back to absolute positions
+            // This correctly handles insertions/deletions around the cursor
+            const anchorAbsPos = Y.createAbsolutePositionFromRelativePosition(anchorRelPos, this.doc);
+            const headAbsPos = Y.createAbsolutePositionFromRelativePosition(headRelPos, this.doc);
+            // Convert back to editor positions with bounds checking
+            const maxIndex = content.length;
+            const newAnchorIndex = anchorAbsPos ? Math.min(anchorAbsPos.index, maxIndex) : 0;
+            const newHeadIndex = headAbsPos ? Math.min(headAbsPos.index, maxIndex) : 0;
+            const newAnchor = this.indexToPosition(newAnchorIndex);
+            const newHead = this.indexToPosition(newHeadIndex);
+            // Apply content and selection atomically without triggering intermediate events
+            // This prevents race conditions where selection listeners modify state during update
+            this.editorState.runWithoutNotifications(() => {
+                this.editorState.setContent(content);
+                this.editorState.setSelection(newAnchor, newHead);
+            });
+        }
+        finally {
+            this.isUpdating = false;
+        }
+    }
+    /**
+     * Convert position to index using provided lines (for atomic operations)
+     */
+    positionToIndexWithLines(position, lines) {
+        let index = 0;
+        // Clamp line to valid range
+        const lineNum = Math.min(position.line, lines.length - 1);
+        if (lineNum < 0)
+            return 0;
+        for (let i = 0; i < lineNum; i++) {
+            index += (lines[i]?.text.length ?? 0) + 1; // +1 for newline
+        }
+        // Clamp column to valid range for this line
+        const lineLength = lines[lineNum]?.text.length ?? 0;
+        index += Math.min(position.column, lineLength);
+        return index;
+    }
+    /**
+     * Handle local editor changes
+     */
+    handleLocalChange(event) {
+        this.isUpdating = true;
+        try {
+            this.doc.transact(() => {
+                switch (event.type) {
+                    case 'insert':
+                        if (event.text) {
+                            const index = this.positionToIndex(event.from);
+                            this.text.insert(index, event.text);
+                        }
+                        break;
+                    case 'delete':
+                        if (event.to) {
+                            const fromIndex = this.positionToIndex(event.from);
+                            const toIndex = this.positionToIndex(event.to);
+                            this.text.delete(fromIndex, toIndex - fromIndex);
+                        }
+                        break;
+                    case 'replace': {
+                        // A `replace` rewrites the whole document (setContent, undo/redo,
+                        // replace-all, external load). The event's from/to are computed
+                        // against the POST-change line array, but the Yjs text still holds
+                        // the OLD content here, so deriving a delete range from them would
+                        // target the wrong span and corrupt the shared doc.
+                        //
+                        // Make replace robust: delete the entire current Yjs range and
+                        // insert the full new content. This is correct regardless of the
+                        // from/to positions carried on the event.
+                        const currentLength = this.text.length;
+                        if (currentLength > 0) {
+                            this.text.delete(0, currentLength);
+                        }
+                        if (event.text) {
+                            this.text.insert(0, event.text);
+                        }
+                        break;
+                    }
+                }
+            });
+        }
+        finally {
+            this.isUpdating = false;
+        }
+    }
+    /**
+     * Convert editor position to CRDT index
+     */
+    positionToIndex(position) {
+        return this.positionToIndexWithLines(position, this.editorState.lines);
+    }
+    /**
+     * Convert CRDT index to editor position
+     */
+    indexToPosition(index) {
+        const lines = this.editorState.lines;
+        // Handle edge cases
+        if (lines.length === 0)
+            return { line: 0, column: 0 };
+        if (index <= 0)
+            return { line: 0, column: 0 };
+        let remaining = index;
+        let line = 0;
+        while (line < lines.length) {
+            const lineText = lines[line]?.text ?? '';
+            const lineLength = lineText.length + 1; // +1 for newline
+            // For the last line, don't add newline to length calculation
+            const isLastLine = line === lines.length - 1;
+            const effectiveLength = isLastLine ? lineText.length : lineLength;
+            if (remaining <= effectiveLength) {
+                return { line, column: Math.min(remaining, lineText.length) };
+            }
+            remaining -= lineLength;
+            line++;
+        }
+        // At end of document - clamp to last valid position
+        const lastLine = lines.length - 1;
+        return {
+            line: lastLine,
+            column: lines[lastLine]?.text.length ?? 0
+        };
+    }
+    /**
+     * Apply a full local content replacement into the bound editor state,
+     * which propagates to the CRDT / Yjs text via the local-change listener.
+     *
+     * Use this for edits that originate outside the bound EditorState (e.g. an
+     * inner editor component that maintains its own state) so that local typing
+     * reaches collaborators. No-op while a remote update is being applied, which
+     * also prevents a remote -> local -> remote echo loop.
+     *
+     * @returns `true` if the content changed and was propagated, `false` otherwise.
+     */
+    setContent(content) {
+        // Guard against echoing a remote update back into the CRDT.
+        if (this.isDestroyed || this.isUpdating)
+            return false;
+        // Skip no-op writes (content already matches the editor state).
+        if (this.editorState.getContent() === content)
+            return false;
+        this.editorState.setContent(content);
+        return true;
+    }
+    /**
+     * Whether a remote (CRDT-originated) update is currently being applied.
+     * Callers can use this to suppress re-sending an echoed local change.
+     */
+    get isApplyingRemoteChange() {
+        return this.isUpdating;
+    }
+    /**
+     * Get the Yjs text type
+     */
+    getText() {
+        return this.text;
+    }
+    /**
+     * Get the Yjs document
+     */
+    getDoc() {
+        return this.doc;
+    }
+    /**
+     * Clean up bindings
+     */
+    destroy() {
+        // Prevent further operations
+        this.isDestroyed = true;
+        // Run all cleanup functions
+        for (const cleanup of this.cleanupFns) {
+            try {
+                cleanup();
+            }
+            catch {
+                // Ignore cleanup errors to ensure all cleanups run
+            }
+        }
+        this.cleanupFns = [];
+        this.textObserver = null;
+    }
+}
+/**
+ * Create a CRDT binding
+ */
+export function createCRDTBinding(config) {
+    return new CRDTBinding(config);
+}
+/**
+ * Create a relative position from an editor position
+ */
+export function createRelativePosition(text, binding, position) {
+    const index = binding.positionToIndex(position);
+    const yRelPos = Y.createRelativePositionFromTypeIndex(text, index);
+    return { yRelPos };
+}
+/**
+ * Resolve a relative position to an editor position
+ */
+export function resolveRelativePosition(doc, binding, relPos) {
+    const absPos = Y.createAbsolutePositionFromRelativePosition(relPos.yRelPos, doc);
+    if (!absPos)
+        return null;
+    return binding.indexToPosition(absPos.index);
+}

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

@@ -0,0 +1,210 @@
+/**
+ * Diagnostics Manager
+ *
+ * Manages code diagnostics including:
+ * - Errors, warnings, info, hints
+ * - Quick fixes and code actions
+ * - Diagnostic sources (TypeScript, ESLint, etc.)
+ */
+export interface Position {
+    line: number;
+    column: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export type DiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
+export interface DiagnosticRelatedInfo {
+    /** Location of related info */
+    range: Range;
+    /** Message */
+    message: string;
+    /** File path if different from main diagnostic */
+    filePath?: string;
+}
+export interface DiagnosticTag {
+    /** Deprecated code */
+    deprecated?: boolean;
+    /** Unnecessary code (e.g., unused imports) */
+    unnecessary?: boolean;
+}
+export interface Diagnostic {
+    /** Unique identifier */
+    id: string;
+    /** Range of the diagnostic */
+    range: Range;
+    /** Severity level */
+    severity: DiagnosticSeverity;
+    /** Main message */
+    message: string;
+    /** Source of the diagnostic (e.g., "typescript", "eslint") */
+    source: string;
+    /** Error/warning code */
+    code?: string | number;
+    /** URL for more information */
+    codeUrl?: string;
+    /** Related information */
+    relatedInfo?: DiagnosticRelatedInfo[];
+    /** Tags for special rendering */
+    tags?: DiagnosticTag;
+    /** Suggested fixes */
+    fixes?: DiagnosticFix[];
+}
+export interface DiagnosticFix {
+    /** Fix title */
+    title: string;
+    /** Whether this is the preferred fix */
+    isPreferred?: boolean;
+    /** Text edits to apply */
+    edits: TextEdit[];
+}
+export interface TextEdit {
+    /** Range to replace */
+    range: Range;
+    /** New text */
+    newText: string;
+}
+export interface DiagnosticFilter {
+    /** Filter by severity */
+    severity?: DiagnosticSeverity[];
+    /** Filter by source */
+    source?: string[];
+    /** Filter by file path */
+    filePath?: string;
+    /** Search text in messages */
+    searchText?: string;
+}
+export interface DiagnosticsConfig {
+    /** Whether diagnostics are enabled */
+    enabled: boolean;
+    /** Show inline decorations */
+    showInline: boolean;
+    /** Show gutter icons */
+    showGutterIcons: boolean;
+    /** Delay before showing diagnostics (ms) */
+    showDelay: number;
+    /** Maximum diagnostics per file */
+    maxPerFile: number;
+    /** Severity to show (filter) */
+    severityFilter: DiagnosticSeverity[];
+}
+type Listener = () => void;
+/**
+ * Diagnostics Manager
+ */
+export declare class DiagnosticsManager {
+    private _config;
+    private _diagnostics;
+    private _listeners;
+    private _idCounter;
+    /**
+     * Set diagnostics for a file
+     */
+    setDiagnostics(filePath: string, diagnostics: Omit<Diagnostic, 'id'>[]): void;
+    /**
+     * Add diagnostics to a file
+     */
+    addDiagnostics(filePath: string, diagnostics: Omit<Diagnostic, 'id'>[]): void;
+    /**
+     * Clear diagnostics for a file
+     */
+    clearDiagnostics(filePath: string): void;
+    /**
+     * Clear all diagnostics
+     */
+    clearAll(): void;
+    /**
+     * Get diagnostics for a file
+     */
+    getDiagnostics(filePath: string): Diagnostic[];
+    /**
+     * Get all diagnostics
+     */
+    getAllDiagnostics(): Map<string, Diagnostic[]>;
+    /**
+     * Get diagnostics at a specific position
+     */
+    getDiagnosticsAtPosition(filePath: string, position: Position): Diagnostic[];
+    /**
+     * Get diagnostics for a line
+     */
+    getDiagnosticsForLine(filePath: string, line: number): Diagnostic[];
+    /**
+     * Get counts by severity
+     */
+    getCounts(filePath?: string): Record<DiagnosticSeverity, number>;
+    /**
+     * Get total count
+     */
+    getTotalCount(filePath?: string): number;
+    /**
+     * Check if position is in range
+     */
+    private positionInRange;
+    /**
+     * Filter diagnostics by config
+     */
+    private filterDiagnostics;
+    /**
+     * Apply a fix
+     */
+    applyFix(diagnostic: Diagnostic, fix: DiagnosticFix): TextEdit[];
+    /**
+     * Get config
+     */
+    get config(): DiagnosticsConfig;
+    /**
+     * Update config
+     */
+    setConfig(config: Partial<DiagnosticsConfig>): void;
+    /**
+     * Enable/disable
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Set severity filter
+     */
+    setSeverityFilter(severities: DiagnosticSeverity[]): void;
+    /**
+     * Subscribe to changes
+     */
+    subscribe(listener: Listener): () => void;
+    /**
+     * Notify listeners
+     */
+    private notify;
+    /**
+     * Clean up
+     */
+    destroy(): void;
+}
+/**
+ * Create a new DiagnosticsManager instance
+ */
+export declare function createDiagnosticsManager(): DiagnosticsManager;
+/**
+ * Get severity icon
+ */
+export declare function getSeverityIcon(severity: DiagnosticSeverity): string;
+/**
+ * Get severity color
+ */
+export declare function getSeverityColor(severity: DiagnosticSeverity): string;
+/**
+ * Get severity label
+ */
+export declare function getSeverityLabel(severity: DiagnosticSeverity): string;
+/**
+ * Sort diagnostics by severity then line
+ */
+export declare function sortDiagnostics(diagnostics: Diagnostic[]): Diagnostic[];
+/**
+ * Generate mock diagnostics for testing
+ */
+export declare function generateMockDiagnostics(lineCount: number): Diagnostic[];
+export {};