@nocturnium/svelte-ide 1.1.1 → 1.2.1

package/dist/components/editor/core/crdt-binding.d.ts

@@ -51,6 +51,10 @@ export declare class CRDTBinding {
      * Uses Yjs relative positions for accurate cursor preservation during concurrent edits
      */
     private handleCRDTChange;
+    /**
+     * Apply a Y.Text delta to the editor using bounded index-based edit paths.
+     */
+    private applyCRDTDelta;
     /**
      * Convert position to index using provided lines (for atomic operations)
      */

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

@@ -67,7 +67,7 @@ export class CRDTBinding {
      * Handle changes from CRDT
      * Uses Yjs relative positions for accurate cursor preservation during concurrent edits
      */
-    handleCRDTChange(_event) {
+    handleCRDTChange(event) {
         this.isUpdating = true;
         try {
             // Capture current selection as relative positions BEFORE applying changes
@@ -78,22 +78,20 @@ export class CRDTBinding {
             // 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 maxIndex = this.text.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.applyCRDTDelta(event.delta);
+                const newAnchor = this.indexToPosition(newAnchorIndex);
+                const newHead = this.indexToPosition(newHeadIndex);
                 this.editorState.setSelection(newAnchor, newHead);
             });
         }
@@ -101,6 +99,28 @@ export class CRDTBinding {
             this.isUpdating = false;
         }
     }
+    /**
+     * Apply a Y.Text delta to the editor using bounded index-based edit paths.
+     */
+    applyCRDTDelta(delta) {
+        let index = 0;
+        for (const op of delta) {
+            if (op.retain) {
+                index += op.retain;
+            }
+            if (op.insert !== undefined) {
+                const insertedText = String(op.insert);
+                const position = this.indexToPosition(index);
+                this.editorState.insertAt(position, insertedText);
+                index += insertedText.length;
+            }
+            if (op.delete) {
+                const from = this.indexToPosition(index);
+                const to = this.indexToPosition(index + op.delete);
+                this.editorState.deleteRange(from, to);
+            }
+        }
+    }
     /**
      * Convert position to index using provided lines (for atomic operations)
      */
@@ -153,8 +173,13 @@ export class CRDTBinding {
                         if (currentLength > 0) {
                             this.text.delete(0, currentLength);
                         }
-                        if (event.text) {
-                            this.text.insert(0, event.text);
+                        // Source the full content from the editor itself, not from
+                        // event.text: undo/redo emit a `replace` with no `text`, so
+                        // trusting event.text here would empty the shared doc. getContent()
+                        // is the authoritative post-change content for any replace emitter.
+                        const fullContent = this.editorState.getContent();
+                        if (fullContent) {
+                            this.text.insert(0, fullContent);
                         }
                         break;
                     }

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

@@ -5,7 +5,7 @@
  * keystrokes with a configurable delay. Type in one place, and edits
  * propagate to echo locations with visible animation.
  */
-import type { Position } from './state';
+import { EditorState, type Position } from './state';
 /**
  * Keystroke event for replay
  */
@@ -24,6 +24,8 @@ export interface KeystrokeEvent {
         direction?: 'forward' | 'backward';
         /** Count for delete */
         count?: number;
+        /** Removed text for delete replay */
+        removed?: string;
         /** New position for move */
         position?: Position;
     };
@@ -107,7 +109,10 @@ export declare class EchoCursorManager {
     private echoCursors;
     private keystrokeBuffer;
     private replayTimers;
+    private echoMirrors;
     private listeners;
+    private detachEditorState;
+    private attachedEditorState;
     private enabled;
     private colorIndex;
     constructor(config?: Partial<EchoCursorConfig>);
@@ -127,6 +132,10 @@ export declare class EchoCursorManager {
      * Check if echo mode is enabled
      */
     isEnabled(): boolean;
+    /**
+     * Attach echo recording to a real editor state.
+     */
+    attach(editorState: EditorState): () => void;
     /**
      * Add an echo cursor at a position
      */
@@ -170,6 +179,10 @@ export declare class EchoCursorManager {
      * Get echo cursor by ID
      */
     getEchoCursor(id: string): EchoCursor | undefined;
+    /**
+     * Get the real mirrored buffer content for an echo cursor.
+     */
+    getEchoContent(id: string): string;
     /**
      * Get keystroke buffer
      */
@@ -186,6 +199,10 @@ export declare class EchoCursorManager {
      * Schedule keystroke replay for an echo cursor
      */
     private scheduleReplay;
+    private recordChangeEvent;
+    private getReplayText;
+    private positionAfterText;
+    private positionBeforeText;
     /**
      * Emit event to listeners
      */

package/dist/components/editor/core/echo-cursor.js

@@ -5,6 +5,7 @@
  * keystrokes with a configurable delay. Type in one place, and edits
  * propagate to echo locations with visible animation.
  */
+import { EditorState } from './state';
 const DEFAULT_CONFIG = {
     defaultDelay: 150,
     maxEchoCursors: 10,
@@ -30,7 +31,10 @@ export class EchoCursorManager {
     echoCursors = new Map();
     keystrokeBuffer = [];
     replayTimers = new Map();
+    echoMirrors = new Map();
     listeners = new Set();
+    detachEditorState = null;
+    attachedEditorState = null;
     enabled = false;
     colorIndex = 0;
     constructor(config = {}) {
@@ -69,6 +73,21 @@ export class EchoCursorManager {
     isEnabled() {
         return this.enabled;
     }
+    /**
+     * Attach echo recording to a real editor state.
+     */
+    attach(editorState) {
+        this.detachEditorState?.();
+        this.attachedEditorState = editorState;
+        this.detachEditorState = editorState.onContentChange((event) => this.recordChangeEvent(event));
+        return () => {
+            if (this.attachedEditorState === editorState) {
+                this.detachEditorState?.();
+                this.detachEditorState = null;
+                this.attachedEditorState = null;
+            }
+        };
+    }
     /**
      * Add an echo cursor at a position
      */
@@ -92,6 +111,9 @@ export class EchoCursorManager {
         };
         this.echoCursors.set(id, cursor);
         this.replayTimers.set(id, []);
+        this.echoMirrors.set(id, new EditorState({
+            content: this.attachedEditorState?.getContent() ?? ''
+        }));
         this.emit({ type: 'echo-added', cursor });
         return cursor;
     }
@@ -108,6 +130,7 @@ export class EchoCursorManager {
             clearTimeout(timer);
         }
         this.replayTimers.delete(id);
+        this.echoMirrors.delete(id);
         this.echoCursors.delete(id);
         this.emit({ type: 'echo-removed', cursorId: id });
         return true;
@@ -192,6 +215,12 @@ export class EchoCursorManager {
     getEchoCursor(id) {
         return this.echoCursors.get(id);
     }
+    /**
+     * Get the real mirrored buffer content for an echo cursor.
+     */
+    getEchoContent(id) {
+        return this.echoMirrors.get(id)?.getContent() ?? '';
+    }
     /**
      * Get keystroke buffer
      */
@@ -221,19 +250,101 @@ export class EchoCursorManager {
         if (!cursor.active)
             return;
         const timer = setTimeout(() => {
+            const mirror = this.echoMirrors.get(cursor.id);
+            if (!mirror)
+                return;
             cursor.isReplaying = true;
             this.emit({ type: 'replay-started', cursorId: cursor.id, keystroke });
-            // Simulate replay completion after a short animation time
-            setTimeout(() => {
-                cursor.isReplaying = false;
-                cursor.replayIndex++;
-                this.emit({ type: 'replay-completed', cursorId: cursor.id, keystroke });
-            }, 50);
+            if (keystroke.type === 'insert' || keystroke.type === 'newline' || keystroke.type === 'tab') {
+                const text = this.getReplayText(keystroke);
+                if (text) {
+                    mirror.insertAt(cursor.position, text);
+                    this.updateEchoPosition(cursor.id, mirror.cursor);
+                }
+            }
+            else if (keystroke.type === 'delete') {
+                const removed = keystroke.data.removed ?? ''.padStart(keystroke.data.count ?? 1, ' ');
+                const from = keystroke.data.direction === 'forward'
+                    ? cursor.position
+                    : this.positionBeforeText(mirror, cursor.position, removed);
+                const to = keystroke.data.direction === 'forward'
+                    ? this.positionAfterText(mirror, cursor.position, removed)
+                    : cursor.position;
+                mirror.deleteRange(from, to);
+                this.updateEchoPosition(cursor.id, mirror.cursor);
+            }
+            cursor.isReplaying = false;
+            cursor.replayIndex++;
+            this.emit({ type: 'replay-completed', cursorId: cursor.id, keystroke });
         }, cursor.delayMs);
         const timers = this.replayTimers.get(cursor.id) || [];
         timers.push(timer);
         this.replayTimers.set(cursor.id, timers);
     }
+    recordChangeEvent(event) {
+        if (event.type === 'insert' && event.text) {
+            this.recordInsert(event.text);
+            return;
+        }
+        if (event.type === 'delete' && event.removed) {
+            this.recordKeystroke({
+                type: 'delete',
+                data: {
+                    direction: 'backward',
+                    count: event.removed.length,
+                    removed: event.removed
+                }
+            });
+            return;
+        }
+        if (event.type === 'replace') {
+            if (event.removed) {
+                this.recordKeystroke({
+                    type: 'delete',
+                    data: {
+                        direction: 'backward',
+                        count: event.removed.length,
+                        removed: event.removed
+                    }
+                });
+            }
+            if (event.text) {
+                this.recordInsert(event.text);
+            }
+        }
+    }
+    getReplayText(keystroke) {
+        if (keystroke.type === 'newline')
+            return '\n';
+        if (keystroke.type === 'tab')
+            return '\t';
+        return keystroke.data.text ?? '';
+    }
+    positionAfterText(mirror, position, text) {
+        const lines = text.split('\n');
+        if (lines.length === 1) {
+            return { line: position.line, column: position.column + text.length };
+        }
+        return {
+            line: Math.min(position.line + lines.length - 1, mirror.lineCount - 1),
+            column: lines[lines.length - 1].length
+        };
+    }
+    positionBeforeText(mirror, position, text) {
+        const lines = text.split('\n');
+        if (lines.length === 1) {
+            return {
+                line: position.line,
+                column: Math.max(0, position.column - text.length)
+            };
+        }
+        const line = Math.max(0, position.line - lines.length + 1);
+        const lineText = mirror.getLine(line)?.text ?? '';
+        return {
+            line,
+            column: Math.max(0, lineText.length - lines[0].length)
+        };
+    }
     /**
      * Emit event to listeners
      */

package/dist/components/editor/core/extract-function.d.ts

@@ -0,0 +1,27 @@
+export type ExtractPlan = {
+    ok: true;
+    functionText: string;
+    callText: string;
+    params: string[];
+    returns: string[];
+    insertAfterLine: number;
+};
+export type ExtractRefusal = {
+    ok: false;
+    reason: string;
+};
+type ExtractInput = {
+    lines: readonly {
+        text: string;
+    }[];
+    language: string;
+    region: {
+        startLine: number;
+        endLine: number;
+        type?: string;
+    };
+    blockStart?: number;
+    blockEnd?: number;
+};
+export declare function planExtractFunction(input: ExtractInput): ExtractPlan | ExtractRefusal;
+export {};