@nocturnium/svelte-ide 1.0.0-rc.1

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

@@ -0,0 +1,267 @@
+/**
+ * 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.
+ */
+const DEFAULT_CONFIG = {
+    defaultDelay: 150,
+    maxEchoCursors: 10,
+    maxKeystrokeBuffer: 1000,
+    colors: [
+        '#22c55e', // green
+        '#f59e0b', // amber
+        '#ec4899', // pink
+        '#06b6d4', // cyan
+        '#8b5cf6', // violet
+        '#ef4444', // red
+        '#14b8a6', // teal
+        '#f97316', // orange
+        '#6366f1', // indigo
+        '#84cc16' // lime
+    ]
+};
+/**
+ * Echo Cursor Manager
+ */
+export class EchoCursorManager {
+    config;
+    echoCursors = new Map();
+    keystrokeBuffer = [];
+    replayTimers = new Map();
+    listeners = new Set();
+    enabled = false;
+    colorIndex = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Enable echo mode
+     */
+    enable() {
+        this.enabled = true;
+        this.emit({ type: 'mode-changed', enabled: true });
+    }
+    /**
+     * Disable echo mode
+     */
+    disable() {
+        this.enabled = false;
+        this.clearAllEchoes();
+        this.emit({ type: 'mode-changed', enabled: false });
+    }
+    /**
+     * Toggle echo mode
+     */
+    toggle() {
+        if (this.enabled) {
+            this.disable();
+        }
+        else {
+            this.enable();
+        }
+        return this.enabled;
+    }
+    /**
+     * Check if echo mode is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Add an echo cursor at a position
+     */
+    addEchoPoint(position, options) {
+        if (!this.enabled)
+            return null;
+        if (this.echoCursors.size >= this.config.maxEchoCursors)
+            return null;
+        const id = `echo-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const color = this.config.colors[this.colorIndex % this.config.colors.length];
+        this.colorIndex++;
+        const cursor = {
+            id,
+            position: { ...position },
+            delayMs: options?.delay ?? this.config.defaultDelay,
+            color,
+            active: true,
+            replayIndex: this.keystrokeBuffer.length, // Start from current position
+            isReplaying: false,
+            label: options?.label
+        };
+        this.echoCursors.set(id, cursor);
+        this.replayTimers.set(id, []);
+        this.emit({ type: 'echo-added', cursor });
+        return cursor;
+    }
+    /**
+     * Remove an echo cursor
+     */
+    removeEcho(id) {
+        const cursor = this.echoCursors.get(id);
+        if (!cursor)
+            return false;
+        // Clear pending replay timers
+        const timers = this.replayTimers.get(id) || [];
+        for (const timer of timers) {
+            clearTimeout(timer);
+        }
+        this.replayTimers.delete(id);
+        this.echoCursors.delete(id);
+        this.emit({ type: 'echo-removed', cursorId: id });
+        return true;
+    }
+    /**
+     * Clear all echo cursors
+     */
+    clearAllEchoes() {
+        for (const id of this.echoCursors.keys()) {
+            this.removeEcho(id);
+        }
+        this.keystrokeBuffer = [];
+    }
+    /**
+     * Record a keystroke from the primary cursor
+     */
+    recordKeystroke(event) {
+        const keystroke = {
+            ...event,
+            id: `ks-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: Date.now()
+        };
+        this.keystrokeBuffer.push(keystroke);
+        // Prune old keystrokes
+        if (this.keystrokeBuffer.length > this.config.maxKeystrokeBuffer) {
+            this.keystrokeBuffer = this.keystrokeBuffer.slice(-this.config.maxKeystrokeBuffer);
+        }
+        this.emit({ type: 'keystroke-recorded', event: keystroke });
+        // Schedule replay for all echo cursors
+        if (this.enabled) {
+            for (const cursor of this.echoCursors.values()) {
+                this.scheduleReplay(cursor, keystroke);
+            }
+        }
+        return keystroke;
+    }
+    /**
+     * Record text insertion
+     */
+    recordInsert(text) {
+        return this.recordKeystroke({
+            type: 'insert',
+            data: { text }
+        });
+    }
+    /**
+     * Record text deletion
+     */
+    recordDelete(direction, count = 1) {
+        return this.recordKeystroke({
+            type: 'delete',
+            data: { direction, count }
+        });
+    }
+    /**
+     * Record newline insertion
+     */
+    recordNewline() {
+        return this.recordKeystroke({
+            type: 'newline',
+            data: {}
+        });
+    }
+    /**
+     * Record tab insertion
+     */
+    recordTab() {
+        return this.recordKeystroke({
+            type: 'tab',
+            data: {}
+        });
+    }
+    /**
+     * Get all echo cursors
+     */
+    getEchoCursors() {
+        return Array.from(this.echoCursors.values());
+    }
+    /**
+     * Get echo cursor by ID
+     */
+    getEchoCursor(id) {
+        return this.echoCursors.get(id);
+    }
+    /**
+     * Get keystroke buffer
+     */
+    getKeystrokeBuffer() {
+        return this.keystrokeBuffer;
+    }
+    /**
+     * Update echo cursor position after replay
+     */
+    updateEchoPosition(id, position) {
+        const cursor = this.echoCursors.get(id);
+        if (cursor) {
+            cursor.position = { ...position };
+        }
+    }
+    /**
+     * Subscribe to echo cursor events
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * Schedule keystroke replay for an echo cursor
+     */
+    scheduleReplay(cursor, keystroke) {
+        if (!cursor.active)
+            return;
+        const timer = setTimeout(() => {
+            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);
+        }, cursor.delayMs);
+        const timers = this.replayTimers.get(cursor.id) || [];
+        timers.push(timer);
+        this.replayTimers.set(cursor.id, timers);
+    }
+    /**
+     * Emit event to listeners
+     */
+    emit(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch (e) {
+                console.error('[EchoCursorManager] Listener error:', e);
+            }
+        }
+    }
+}
+/**
+ * Create an echo cursor manager
+ */
+export function createEchoCursorManager(config) {
+    return new EchoCursorManager(config);
+}
+// Singleton instance
+let globalEchoCursorManager = null;
+/**
+ * Get the global echo cursor manager
+ */
+export function getEchoCursorManager() {
+    if (!globalEchoCursorManager) {
+        globalEchoCursorManager = createEchoCursorManager();
+    }
+    return globalEchoCursorManager;
+}

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

@@ -0,0 +1,124 @@
+/**
+ * Code folding detection and management
+ *
+ * Supports multiple folding strategies:
+ * - Indentation-based (Python, YAML)
+ * - Bracket-based (JavaScript, TypeScript, JSON, etc.)
+ * - Region markers (#region / #endregion)
+ */
+import type { Line } from './state';
+/**
+ * A foldable region in the document
+ */
+export interface FoldRegion {
+    /** Start line (0-based) - the line with the fold indicator */
+    startLine: number;
+    /** End line (0-based) - the last line included in the fold */
+    endLine: number;
+    /** Indentation level (for nested folds) */
+    level: number;
+    /** Type of fold region */
+    type: 'bracket' | 'indentation' | 'region' | 'comment';
+    /** Whether this region is currently collapsed */
+    collapsed: boolean;
+}
+/**
+ * Folding strategy configuration
+ */
+export interface FoldingConfig {
+    /** Enable bracket-based folding */
+    brackets: boolean;
+    /** Enable indentation-based folding */
+    indentation: boolean;
+    /** Enable region marker folding */
+    regions: boolean;
+    /** Enable multi-line comment folding */
+    comments: boolean;
+    /** Minimum lines for a foldable region */
+    minLines: number;
+}
+/**
+ * Detect all fold regions in a document
+ */
+export declare function detectFoldRegions(lines: readonly Line[], language?: string, config?: Partial<FoldingConfig>): FoldRegion[];
+/**
+ * Fold state manager
+ */
+export declare class FoldManager {
+    private regions;
+    private collapsedLines;
+    private listeners;
+    /**
+     * Update fold regions based on document content
+     */
+    updateRegions(lines: readonly Line[], language: string, config?: Partial<FoldingConfig>): void;
+    /**
+     * Get all fold regions
+     */
+    getRegions(): readonly FoldRegion[];
+    /**
+     * Get fold region at a specific line (if it starts there)
+     */
+    getRegionAtLine(line: number): FoldRegion | undefined;
+    /**
+     * Check if a line is hidden (inside a collapsed fold)
+     */
+    isLineHidden(line: number): boolean;
+    /**
+     * Check if a line has a fold indicator
+     */
+    hasFoldIndicator(line: number): boolean;
+    /**
+     * Check if the fold at this line is collapsed
+     */
+    isFoldCollapsed(line: number): boolean;
+    /**
+     * Toggle fold at a line
+     */
+    toggleFold(line: number): boolean;
+    /**
+     * Collapse fold at a line
+     */
+    collapse(line: number): boolean;
+    /**
+     * Expand fold at a line
+     */
+    expand(line: number): boolean;
+    /**
+     * Collapse all folds
+     */
+    collapseAll(): void;
+    /**
+     * Expand all folds
+     */
+    expandAll(): void;
+    /**
+     * Collapse folds at a specific nesting level
+     */
+    collapseLevel(level: number): void;
+    /**
+     * Get visible lines (line numbers that should be rendered)
+     */
+    getVisibleLines(totalLines: number): number[];
+    /**
+     * Get the number of hidden lines after a fold start
+     */
+    getHiddenLineCount(startLine: number): number;
+    /**
+     * Update the set of collapsed (hidden) lines
+     */
+    private updateCollapsedLines;
+    /** Maximum listeners to prevent memory leaks */
+    private static readonly MAX_LISTENERS;
+    /**
+     * Subscribe to fold changes
+     * In development mode, throws an error to catch memory leaks early.
+     * In production, warns and evicts the oldest listener.
+     */
+    onChange(callback: () => void): () => void;
+    private emit;
+}
+/**
+ * Create a new fold manager
+ */
+export declare function createFoldManager(): FoldManager;