@nocturnium/svelte-ide 1.0.0-rc.1

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

@@ -0,0 +1,357 @@
+/**
+ * Keyboard handling for the custom editor
+ *
+ * This module provides keybinding management and keyboard event handling.
+ */
+/**
+ * Normalize key event to consistent format
+ */
+function normalizeKey(e) {
+    return e.key;
+}
+/**
+ * Check if modifiers match
+ */
+function modifiersMatch(e, modifiers) {
+    const ctrl = modifiers?.ctrl ?? false;
+    const shift = modifiers?.shift ?? false;
+    const alt = modifiers?.alt ?? false;
+    const meta = modifiers?.meta ?? false;
+    // Handle Cmd on Mac as Ctrl
+    const ctrlOrMeta = e.ctrlKey || e.metaKey;
+    return ((ctrl ? ctrlOrMeta : !ctrlOrMeta) &&
+        (shift ? e.shiftKey : !e.shiftKey) &&
+        (alt ? e.altKey : !e.altKey) &&
+        (meta === e.metaKey || ctrl) // Allow meta to match either on its own or as part of ctrl
+    );
+}
+/**
+ * Platform detection
+ */
+const isMac = typeof navigator !== 'undefined' && /Mac/.test(navigator.platform);
+/**
+ * Create default keybindings for the editor
+ */
+export function createDefaultKeybindings(state, nav, options = {}) {
+    const pageSize = options.pageSize ?? 20;
+    const keybindings = [];
+    // ============================================
+    // Navigation
+    // ============================================
+    // Arrow keys
+    keybindings.push({
+        key: 'ArrowLeft',
+        handler: () => nav.moveLeft(),
+        description: 'Move cursor left',
+        readonly: true
+    }, {
+        key: 'ArrowLeft',
+        modifiers: { shift: true },
+        handler: () => nav.moveLeft(true),
+        description: 'Extend selection left',
+        readonly: true
+    }, {
+        key: 'ArrowRight',
+        handler: () => nav.moveRight(),
+        description: 'Move cursor right',
+        readonly: true
+    }, {
+        key: 'ArrowRight',
+        modifiers: { shift: true },
+        handler: () => nav.moveRight(true),
+        description: 'Extend selection right',
+        readonly: true
+    }, {
+        key: 'ArrowUp',
+        handler: () => nav.moveUp(),
+        description: 'Move cursor up',
+        readonly: true
+    }, {
+        key: 'ArrowUp',
+        modifiers: { shift: true },
+        handler: () => nav.moveUp(true),
+        description: 'Extend selection up',
+        readonly: true
+    }, {
+        key: 'ArrowDown',
+        handler: () => nav.moveDown(),
+        description: 'Move cursor down',
+        readonly: true
+    }, {
+        key: 'ArrowDown',
+        modifiers: { shift: true },
+        handler: () => nav.moveDown(true),
+        description: 'Extend selection down',
+        readonly: true
+    });
+    // Word navigation
+    keybindings.push({
+        key: 'ArrowLeft',
+        modifiers: { ctrl: true },
+        handler: () => nav.moveWordLeft(),
+        description: 'Move to previous word',
+        readonly: true
+    }, {
+        key: 'ArrowLeft',
+        modifiers: { ctrl: true, shift: true },
+        handler: () => nav.moveWordLeft(true),
+        description: 'Extend selection to previous word',
+        readonly: true
+    }, {
+        key: 'ArrowRight',
+        modifiers: { ctrl: true },
+        handler: () => nav.moveWordRight(),
+        description: 'Move to next word',
+        readonly: true
+    }, {
+        key: 'ArrowRight',
+        modifiers: { ctrl: true, shift: true },
+        handler: () => nav.moveWordRight(true),
+        description: 'Extend selection to next word',
+        readonly: true
+    });
+    // Line navigation
+    keybindings.push({
+        key: 'Home',
+        handler: () => nav.moveToLineStart(),
+        description: 'Move to line start',
+        readonly: true
+    }, {
+        key: 'Home',
+        modifiers: { shift: true },
+        handler: () => nav.moveToLineStart(true),
+        description: 'Extend selection to line start',
+        readonly: true
+    }, {
+        key: 'End',
+        handler: () => nav.moveToLineEnd(),
+        description: 'Move to line end',
+        readonly: true
+    }, {
+        key: 'End',
+        modifiers: { shift: true },
+        handler: () => nav.moveToLineEnd(true),
+        description: 'Extend selection to line end',
+        readonly: true
+    });
+    // Document navigation
+    keybindings.push({
+        key: 'Home',
+        modifiers: { ctrl: true },
+        handler: () => nav.moveToDocumentStart(),
+        description: 'Move to document start',
+        readonly: true
+    }, {
+        key: 'Home',
+        modifiers: { ctrl: true, shift: true },
+        handler: () => nav.moveToDocumentStart(true),
+        description: 'Extend selection to document start',
+        readonly: true
+    }, {
+        key: 'End',
+        modifiers: { ctrl: true },
+        handler: () => nav.moveToDocumentEnd(),
+        description: 'Move to document end',
+        readonly: true
+    }, {
+        key: 'End',
+        modifiers: { ctrl: true, shift: true },
+        handler: () => nav.moveToDocumentEnd(true),
+        description: 'Extend selection to document end',
+        readonly: true
+    });
+    // Page navigation
+    keybindings.push({
+        key: 'PageUp',
+        handler: () => nav.movePageUp(pageSize),
+        description: 'Move up one page',
+        readonly: true
+    }, {
+        key: 'PageUp',
+        modifiers: { shift: true },
+        handler: () => nav.movePageUp(pageSize, true),
+        description: 'Extend selection up one page',
+        readonly: true
+    }, {
+        key: 'PageDown',
+        handler: () => nav.movePageDown(pageSize),
+        description: 'Move down one page',
+        readonly: true
+    }, {
+        key: 'PageDown',
+        modifiers: { shift: true },
+        handler: () => nav.movePageDown(pageSize, true),
+        description: 'Extend selection down one page',
+        readonly: true
+    });
+    // ============================================
+    // Selection
+    // ============================================
+    keybindings.push({
+        key: 'a',
+        modifiers: { ctrl: true },
+        handler: () => state.selectAll(),
+        description: 'Select all',
+        readonly: true
+    });
+    // ============================================
+    // Editing (only when not readonly)
+    // ============================================
+    if (!options.readonly) {
+        keybindings.push(
+        // Basic input is handled by onInput, not keybindings
+        // Backspace
+        {
+            key: 'Backspace',
+            handler: () => state.deleteBackward(),
+            description: 'Delete character before cursor'
+        }, {
+            key: 'Backspace',
+            modifiers: { ctrl: true },
+            handler: () => {
+                // Delete word before cursor
+                nav.moveWordLeft(true);
+                state.deleteSelection();
+            },
+            description: 'Delete word before cursor'
+        }, 
+        // Delete
+        {
+            key: 'Delete',
+            handler: () => state.deleteForward(),
+            description: 'Delete character after cursor'
+        }, {
+            key: 'Delete',
+            modifiers: { ctrl: true },
+            handler: () => {
+                // Delete word after cursor
+                nav.moveWordRight(true);
+                state.deleteSelection();
+            },
+            description: 'Delete word after cursor'
+        }, 
+        // Enter
+        {
+            key: 'Enter',
+            handler: () => state.insertNewline(),
+            description: 'Insert new line'
+        }, 
+        // Tab
+        {
+            key: 'Tab',
+            handler: () => state.insertTab(),
+            description: 'Insert tab'
+        }, 
+        // Undo/Redo
+        {
+            key: 'z',
+            modifiers: { ctrl: true },
+            handler: () => state.undo(),
+            description: 'Undo'
+        }, {
+            key: 'z',
+            modifiers: { ctrl: true, shift: true },
+            handler: () => state.redo(),
+            description: 'Redo'
+        }, {
+            key: 'y',
+            modifiers: { ctrl: true },
+            handler: () => state.redo(),
+            description: 'Redo'
+        });
+    }
+    // ============================================
+    // Custom commands
+    // ============================================
+    if (options.onSave) {
+        keybindings.push({
+            key: 's',
+            modifiers: { ctrl: true },
+            handler: () => {
+                options.onSave();
+                return true;
+            },
+            description: 'Save',
+            readonly: true
+        });
+    }
+    return keybindings;
+}
+/**
+ * Keyboard handler class
+ */
+export class KeyboardHandler {
+    keybindings = [];
+    enabled = true;
+    /**
+     * Set keybindings
+     */
+    setKeybindings(keybindings) {
+        this.keybindings = keybindings;
+    }
+    /**
+     * Add a keybinding
+     */
+    addKeybinding(keybinding) {
+        this.keybindings.push(keybinding);
+    }
+    /**
+     * Remove a keybinding
+     */
+    removeKeybinding(key, modifiers) {
+        this.keybindings = this.keybindings.filter((kb) => !(kb.key === key && this.modifiersEqual(kb.modifiers, modifiers)));
+    }
+    /**
+     * Enable/disable keyboard handling
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * Handle a keyboard event
+     * Returns true if the event was handled
+     */
+    handleKeyDown(e, readonly = false) {
+        if (!this.enabled) {
+            return false;
+        }
+        const key = normalizeKey(e);
+        // Find matching keybinding
+        for (const binding of this.keybindings) {
+            if (binding.key === key && modifiersMatch(e, binding.modifiers)) {
+                // Skip non-readonly bindings in readonly mode
+                if (readonly && !binding.readonly) {
+                    continue;
+                }
+                const result = binding.handler();
+                if (result !== false) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if modifiers are equal
+     */
+    modifiersEqual(a, b) {
+        return ((a?.ctrl ?? false) === (b?.ctrl ?? false) &&
+            (a?.shift ?? false) === (b?.shift ?? false) &&
+            (a?.alt ?? false) === (b?.alt ?? false) &&
+            (a?.meta ?? false) === (b?.meta ?? false));
+    }
+    /**
+     * Get all keybindings for documentation
+     */
+    getKeybindings() {
+        return [...this.keybindings];
+    }
+}
+/**
+ * Create keyboard handler
+ */
+export function createKeyboardHandler() {
+    return new KeyboardHandler();
+}

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

@@ -0,0 +1,196 @@
+/**
+ * Multi-cursor management for the custom editor
+ *
+ * Provides support for creating, managing, and editing with multiple cursors.
+ * Cursors can have selections and are automatically merged when they touch or overlap.
+ */
+import type { Position, Selection } from './state';
+/**
+ * A single cursor with optional selection
+ */
+export interface Cursor {
+    /** Unique identifier */
+    id: string;
+    /** Selection range (anchor = head for no selection) */
+    selection: Selection;
+    /** Whether this is the primary cursor */
+    isPrimary: boolean;
+}
+/**
+ * Configuration for CursorManager
+ */
+export interface CursorManagerConfig {
+    /** Maximum number of cursors allowed (default: 100) */
+    maxCursors?: number;
+}
+/**
+ * Compare two positions
+ * Returns negative if a < b, positive if a > b, 0 if equal
+ */
+export declare function comparePositions(a: Position, b: Position): number;
+/**
+ * Check if position a is before position b
+ */
+export declare function isPositionBefore(a: Position, b: Position): boolean;
+/**
+ * Check if position a is before or equal to position b
+ */
+export declare function isPositionBeforeOrEqual(a: Position, b: Position): boolean;
+/**
+ * Check if two positions are equal
+ */
+export declare function positionsEqual(a: Position, b: Position): boolean;
+/**
+ * Get the start position of a selection (min of anchor and head)
+ */
+export declare function getSelectionStart(selection: Selection): Position;
+/**
+ * Get the end position of a selection (max of anchor and head)
+ */
+export declare function getSelectionEnd(selection: Selection): Position;
+/**
+ * Check if a selection is empty (anchor equals head)
+ */
+export declare function isSelectionEmpty(selection: Selection): boolean;
+/**
+ * Check if two selections overlap or touch
+ */
+export declare function selectionsOverlap(a: Selection, b: Selection): boolean;
+/**
+ * Merge two selections into one (union)
+ */
+export declare function mergeSelections(a: Selection, b: Selection): Selection;
+export declare class CursorManager {
+    private cursors;
+    private primaryId;
+    private nextId;
+    private maxCursors;
+    private listeners;
+    constructor(config?: CursorManagerConfig);
+    /**
+     * Get all cursors
+     */
+    getCursors(): readonly Cursor[];
+    /**
+     * Get all cursors sorted by position (top to bottom, left to right)
+     */
+    getSortedCursors(): Cursor[];
+    /**
+     * Get cursors sorted in reverse order (bottom to top)
+     * Useful for editing operations to maintain position validity
+     */
+    getSortedCursorsReverse(): Cursor[];
+    /**
+     * Get the primary cursor
+     */
+    getPrimary(): Cursor;
+    /**
+     * Get cursor count
+     */
+    get count(): number;
+    /**
+     * Check if there are multiple cursors
+     */
+    get hasMultiple(): boolean;
+    /**
+     * Add a new cursor at a position
+     * @param position - Position for the new cursor
+     * @param makePrimary - Make this the primary cursor
+     * @returns The new cursor, or null if at max capacity
+     */
+    addCursor(position: Position, makePrimary?: boolean): Cursor;
+    /**
+     * Add a cursor with a selection
+     */
+    addCursorWithSelection(anchor: Position, head: Position, makePrimary?: boolean): Cursor;
+    /**
+     * Remove a cursor by ID
+     * @returns true if removed, false if it was the last cursor
+     */
+    removeCursor(id: string): boolean;
+    /**
+     * Remove the last added secondary cursor (for Ctrl+U)
+     * @returns true if a cursor was removed
+     */
+    removeLastSecondary(): boolean;
+    /**
+     * Clear all secondary cursors, keeping only the primary
+     */
+    clearSecondary(): void;
+    /**
+     * Set the primary cursor
+     */
+    setPrimary(id: string): void;
+    /**
+     * Set cursor position (clears selection)
+     */
+    setCursor(id: string, position: Position): void;
+    /**
+     * Batch update cursor positions without triggering merge/emit on each update
+     * More efficient for updating multiple cursors at once
+     */
+    batchUpdateCursors(updates: Array<{
+        id: string;
+        position: Position;
+    }>): void;
+    /**
+     * Set cursor selection
+     */
+    setSelection(id: string, anchor: Position, head: Position): void;
+    /**
+     * Extend cursor selection (move head, keep anchor)
+     */
+    extendSelection(id: string, head: Position): void;
+    /**
+     * Set all cursors to new positions (for single cursor operations)
+     */
+    setSingleCursor(position: Position): void;
+    /**
+     * Set single cursor with selection
+     */
+    setSingleSelection(anchor: Position, head: Position): void;
+    /**
+     * Check if any cursor contains a position
+     */
+    isPositionInAnyCursor(position: Position): boolean;
+    /**
+     * Get the closest cursor to a position
+     */
+    private getClosestCursor;
+    /**
+     * Merge overlapping or touching cursors
+     */
+    private mergeTouchingCursors;
+    /**
+     * Add cursor above the current primary cursor
+     * @param lineCount - Number of lines in the document
+     */
+    addCursorAbove(lineCount: number): boolean;
+    /**
+     * Add cursor below the current primary cursor
+     * @param lineCount - Number of lines in the document
+     */
+    addCursorBelow(lineCount: number): boolean;
+    /**
+     * Subscribe to cursor 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;
+    /**
+     * Restore cursors from a saved state (for undo/redo)
+     */
+    restore(cursors: Cursor[], primaryId: string): void;
+    /**
+     * Clone the current state (for undo/redo)
+     */
+    clone(): {
+        cursors: Cursor[];
+        primaryId: string;
+    };
+}
+/**
+ * Create a new CursorManager
+ */
+export declare function createCursorManager(config?: CursorManagerConfig): CursorManager;