@termaxjs/editor-react 0.1.1

package/dist/EditorContext.js

@@ -0,0 +1,672 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback, useEffect, useRef, } from "react";
+import { normalizeSelection, isSelectionCollapsed, applyMultiCursorInsert, applyMultiCursorDelete, deduplicateSelections, getTextInRange, getWordRangeAt, positionToOffset, offsetToPosition, isLeadSurrogate, isTrailSurrogate, findWordBoundary, toggleLinesComment, isPairedBracketDelete, isPositionBefore, computeColumnSelection, DEFAULT_UNDO_DEPTH, } from "@termaxjs/editor-core";
+const EDITOR_CONTEXT_KEY = Symbol.for("__termax_editor_context__");
+const editorContextScope = globalThis;
+if (!editorContextScope[EDITOR_CONTEXT_KEY]) {
+    editorContextScope[EDITOR_CONTEXT_KEY] = createContext(null);
+}
+const sharedEditorContext = editorContextScope[EDITOR_CONTEXT_KEY];
+if (!sharedEditorContext) {
+    throw new Error("Failed to initialize the editor context");
+}
+export const EditorContext = sharedEditorContext;
+const MAX_UNDO_DEPTH = DEFAULT_UNDO_DEPTH;
+export function EditorProvider({ initialContent = "", adapter, bufferId = "default", onChange, children, }) {
+    const [lines, setLines] = useState(() => {
+        const raw = initialContent || "";
+        return raw.split(/\r?\n/);
+    });
+    // ---------------------------------------------------------------------
+    // Adapter tier wiring (.plan/goal.md E2.2)
+    //
+    // React state remains the synchronous source of truth for rendering — the
+    // adapter contract is async, and blocking a keystroke on a Promise would
+    // regress typing latency. The adapter is instead driven as an authoritative
+    // mirror: every committed mutation is forwarded to it as an offset-based
+    // edit, in order.
+    //
+    // That makes the tier real rather than decorative: with a Tauri/WASM adapter
+    // the Rust rope receives every edit and owns save/large-file handling, while
+    // Tier 0 (no adapter) simply skips the mirror and behaves as before.
+    // ---------------------------------------------------------------------
+    const adapterReady = useRef(false);
+    // Last `lines` value already mirrored to the adapter.
+    const lastSyncedRef = useRef(lines);
+    // Serializes adapter writes. Edits must land in the order they were made,
+    // and the contract is Promise-based, so we chain rather than fire-and-forget.
+    const adapterQueue = useRef(Promise.resolve());
+    const adapterFailed = useRef(false);
+    const enqueueAdapter = useCallback((op) => {
+        if (!adapter || adapterFailed.current)
+            return;
+        adapterQueue.current = adapterQueue.current
+            .then(() => (adapterReady.current ? op(adapter) : undefined))
+            .catch((err) => {
+            // A failing adapter must not silently diverge from the UI. Latch off
+            // and surface it once, rather than logging on every keystroke.
+            adapterFailed.current = true;
+            console.error("[termax-editor] host adapter detached after an error; " +
+                "continuing with in-memory editing only.", err);
+        });
+    }, [adapter]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: initialContent seeds the buffer once; re-opening on every content change would discard the adapter's history.
+    useEffect(() => {
+        if (!adapter) {
+            adapterReady.current = false;
+            return;
+        }
+        adapterFailed.current = false;
+        let cancelled = false;
+        adapterQueue.current = adapterQueue.current
+            .then(() => adapter.openBuffer(bufferId, initialContent ?? ""))
+            .then((snap) => {
+            if (!cancelled) {
+                adapterReady.current = true;
+                setSnapshot(snap ?? null);
+            }
+        })
+            .catch((err) => {
+            adapterFailed.current = true;
+            console.error("[termax-editor] host adapter failed to open buffer.", err);
+        });
+        return () => {
+            cancelled = true;
+            adapterReady.current = false;
+            setSnapshot(null);
+            adapterQueue.current = adapterQueue.current
+                .then(() => adapter.closeBuffer(bufferId))
+                .catch(() => {
+                /* teardown: nothing useful to do with a close failure */
+            });
+        };
+        // initialContent is intentionally excluded: it seeds the buffer once.
+        // Re-opening on every content change would discard the adapter's history.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [adapter, bufferId]);
+    /**
+     * Mirror a committed state transition into the adapter as one offset edit.
+     *
+     * Deliberately diff-based rather than per-operation: it derives the edit from
+     * (prev, next) so a single call site covers insert, delete, tab, bulk
+     * replace, undo and redo alike. A per-operation mirror would need wiring in
+     * each mutation and would silently miss undo/redo, letting the adapter drift
+     * out of sync with the UI — the exact failure this is meant to prevent.
+     */
+    const syncAdapter = useCallback((prevLines, nextLines) => {
+        if (!adapter)
+            return;
+        const prev = prevLines.join("\n");
+        const next = nextLines.join("\n");
+        if (prev === next)
+            return;
+        // Narrow to the changed span: common prefix, then common suffix.
+        let start = 0;
+        const maxStart = Math.min(prev.length, next.length);
+        while (start < maxStart && prev[start] === next[start])
+            start++;
+        let fromEnd = 0;
+        const maxEnd = Math.min(prev.length - start, next.length - start);
+        while (fromEnd < maxEnd &&
+            prev[prev.length - 1 - fromEnd] === next[next.length - 1 - fromEnd]) {
+            fromEnd++;
+        }
+        const deleteLen = prev.length - start - fromEnd;
+        const insertText = next.slice(start, next.length - fromEnd);
+        enqueueAdapter((a) => a.applyEdit(bufferId, start, deleteLen, insertText));
+    }, [adapter, bufferId, enqueueAdapter]);
+    const [selections, setSelectionsState] = useState([
+        { anchor: { line: 0, column: 0 }, head: { line: 0, column: 0 } },
+    ]);
+    const selectionsRef = useRef([
+        { anchor: { line: 0, column: 0 }, head: { line: 0, column: 0 } },
+    ]);
+    const [cursor, setCursorState] = useState({ line: 0, column: 0 });
+    const cursorRef = useRef({ line: 0, column: 0 });
+    const [selection, setSelectionState] = useState(null);
+    const selectionRef = useRef(null);
+    const updateSelections = useCallback((nextSelections) => {
+        const deduped = deduplicateSelections(nextSelections);
+        const valid = deduped.length > 0
+            ? deduped
+            : [{ anchor: { line: 0, column: 0 }, head: { line: 0, column: 0 } }];
+        selectionsRef.current = valid;
+        setSelectionsState(valid);
+        // Sync primary cursor
+        cursorRef.current = valid[0].head;
+        setCursorState(valid[0].head);
+        // Sync primary selection
+        const primRange = isSelectionCollapsed(valid[0]) ? null : normalizeSelection(valid[0]);
+        selectionRef.current = primRange;
+        setSelectionState(primRange);
+    }, []);
+    const updateCursor = useCallback((pos) => {
+        updateSelections([{ anchor: pos, head: pos }]);
+    }, [updateSelections]);
+    const setSelections = useCallback((next) => {
+        updateSelections(next);
+    }, [updateSelections]);
+    const addCursor = useCallback((pos) => {
+        updateSelections([...selectionsRef.current, { anchor: pos, head: pos }]);
+    }, [updateSelections]);
+    const clearSecondaryCursors = useCallback(() => {
+        updateSelections([selectionsRef.current[0]]);
+    }, [updateSelections]);
+    const setSelection = useCallback((valOrFn) => {
+        const prev = selectionRef.current;
+        const next = typeof valOrFn === "function" ? valOrFn(prev) : valOrFn;
+        if (!next) {
+            const cur = cursorRef.current;
+            updateSelections([{ anchor: cur, head: cur }]);
+        }
+        else {
+            updateSelections([{ anchor: next.start, head: next.end }]);
+        }
+    }, [updateSelections]);
+    const [isDirty, setIsDirty] = useState(false);
+    const [visibleRange, setVisibleRange] = useState({ startLine: 0, lineCount: 50 });
+    const [snapshot, setSnapshot] = useState(null);
+    // History stack
+    const undoStack = useRef([]);
+    const redoStack = useRef([]);
+    const pushUndo = useCallback((prevLines, prevSelections) => {
+        undoStack.current.push({ lines: prevLines, selections: prevSelections });
+        if (undoStack.current.length > MAX_UNDO_DEPTH) {
+            undoStack.current.shift();
+        }
+        redoStack.current = [];
+    }, []);
+    // Loads a new document: history is intentionally discarded, because the
+    // previous buffer's undo entries do not describe this one.
+    const setContent = useCallback((newContent) => {
+        const nextLines = newContent.split(/\r?\n/);
+        setLines(nextLines);
+        updateCursor({ line: 0, column: 0 });
+        setIsDirty(false);
+        undoStack.current = [];
+        redoStack.current = [];
+        // Re-seed the adapter: this is a different document, so its edit history
+        // must be dropped there too rather than mirrored as an incremental edit.
+        if (adapter) {
+            lastSyncedRef.current = nextLines;
+            enqueueAdapter((a) => a.openBuffer(bufferId, newContent).then((snap) => {
+                setSnapshot(snap ?? null);
+            }));
+        }
+    }, [updateCursor, adapter, bufferId, enqueueAdapter]);
+    // Edits the current document wholesale, preserving history so the change is
+    // undoable as one step.
+    const replaceContent = useCallback((newContent) => {
+        setLines((prevLines) => {
+            pushUndo(prevLines, selectionsRef.current);
+            const nextLines = newContent.split(/\r?\n/);
+            // Keep the cursor in the document; content length may have shrunk.
+            const cur = cursorRef.current;
+            const line = Math.min(cur.line, Math.max(0, nextLines.length - 1));
+            const column = Math.min(cur.column, (nextLines[line] ?? "").length);
+            updateCursor({ line, column });
+            setIsDirty(true);
+            onChange?.(newContent);
+            return nextLines;
+        });
+    }, [pushUndo, updateCursor, onChange]);
+    // Single mirror point for every mutation. Watching committed `lines` catches
+    // insert, delete, tab, replaceContent, undo and redo without each having to
+    // remember to notify the adapter.
+    useEffect(() => {
+        if (!adapter) {
+            lastSyncedRef.current = lines;
+            return;
+        }
+        const prev = lastSyncedRef.current;
+        if (prev !== lines) {
+            syncAdapter(prev, lines);
+            lastSyncedRef.current = lines;
+        }
+    }, [adapter, lines, syncAdapter]);
+    const getContent = useCallback(() => {
+        return lines.join("\n");
+    }, [lines]);
+    /**
+     * Read the document back from the adapter. On Tier 1/2 this is the Rust
+     * rope's view; on Tier 0 it falls back to local state. Use this rather than
+     * `getContent` when the adapter is authoritative (e.g. before a save).
+     */
+    const getAdapterContent = useCallback(async () => {
+        if (!adapter || adapterFailed.current || !adapterReady.current) {
+            return lines.join("\n");
+        }
+        await adapterQueue.current;
+        return adapter.getContent(bufferId);
+    }, [adapter, bufferId, lines]);
+    const insertText = useCallback((text) => {
+        setLines((prevLines) => {
+            const curSelections = selectionsRef.current;
+            pushUndo(prevLines, curSelections);
+            const { newLines, newSelections } = applyMultiCursorInsert(prevLines, curSelections, text);
+            updateSelections(newSelections);
+            setIsDirty(true);
+            onChange?.(newLines.join("\n"));
+            return newLines;
+        });
+    }, [pushUndo, updateSelections, onChange]);
+    const deleteSelectionOrChar = useCallback((isForward = false) => {
+        setLines((prevLines) => {
+            const curSelections = selectionsRef.current;
+            pushUndo(prevLines, curSelections);
+            let selectionsToUse = curSelections;
+            if (!isForward) {
+                const hasPairedBracket = curSelections.some((s) => isSelectionCollapsed(s) &&
+                    isPairedBracketDelete(prevLines[s.head.line] ?? "", s.head.column));
+                if (hasPairedBracket) {
+                    selectionsToUse = curSelections.map((s) => {
+                        if (isSelectionCollapsed(s) &&
+                            isPairedBracketDelete(prevLines[s.head.line] ?? "", s.head.column)) {
+                            return {
+                                anchor: { line: s.head.line, column: s.head.column - 1 },
+                                head: { line: s.head.line, column: s.head.column + 1 },
+                            };
+                        }
+                        return s;
+                    });
+                }
+            }
+            const { newLines, newSelections } = applyMultiCursorDelete(prevLines, selectionsToUse, isForward);
+            updateSelections(newSelections);
+            setIsDirty(true);
+            onChange?.(newLines.join("\n"));
+            return newLines;
+        });
+    }, [pushUndo, updateSelections, onChange]);
+    const autoCloseOrWrap = useCallback((openChar, closeChar) => {
+        setLines((prevLines) => {
+            const curSelections = selectionsRef.current;
+            pushUndo(prevLines, curSelections);
+            const hasNonCollapsed = curSelections.some((s) => !isSelectionCollapsed(s));
+            if (hasNonCollapsed) {
+                const fullText = prevLines.join("\n");
+                const ranges = curSelections.map((s) => {
+                    const norm = normalizeSelection(s);
+                    const from = positionToOffset(prevLines, norm.start);
+                    const to = positionToOffset(prevLines, norm.end);
+                    return { from, to, isForward: isPositionBefore(s.anchor, s.head) };
+                });
+                ranges.sort((a, b) => a.from - b.from);
+                let result = "";
+                let lastEnd = 0;
+                const newSelections = [];
+                for (const r of ranges) {
+                    result += fullText.slice(lastEnd, r.from);
+                    const insideText = fullText.slice(r.from, r.to);
+                    const wrapStartOffset = result.length;
+                    result += openChar + insideText + closeChar;
+                    const wrapEndOffset = result.length;
+                    lastEnd = r.to;
+                    const tempLines = result.split(/\r?\n/);
+                    const startPos = offsetToPosition(tempLines, wrapStartOffset + openChar.length);
+                    const endPos = offsetToPosition(tempLines, wrapEndOffset - closeChar.length);
+                    newSelections.push(r.isForward ? { anchor: startPos, head: endPos } : { anchor: endPos, head: startPos });
+                }
+                result += fullText.slice(lastEnd);
+                const nextLines = result.split(/\r?\n/);
+                updateSelections(newSelections);
+                setIsDirty(true);
+                onChange?.(nextLines.join("\n"));
+                return nextLines;
+            }
+            const { newLines, newSelections } = applyMultiCursorInsert(prevLines, curSelections, openChar + closeChar);
+            const adjustedSelections = newSelections.map((s) => ({
+                anchor: { line: s.head.line, column: Math.max(0, s.head.column - closeChar.length) },
+                head: { line: s.head.line, column: Math.max(0, s.head.column - closeChar.length) },
+            }));
+            updateSelections(adjustedSelections);
+            setIsDirty(true);
+            onChange?.(newLines.join("\n"));
+            return newLines;
+        });
+    }, [pushUndo, updateSelections, onChange]);
+    const enter = useCallback(() => {
+        insertText("\n");
+    }, [insertText]);
+    const tab = useCallback((isShift = false) => {
+        if (!isShift) {
+            insertText("  "); // 2 spaces by default
+        }
+    }, [insertText]);
+    const moveCursor = useCallback((deltaLine, deltaCol, select = false) => {
+        const curSelections = selectionsRef.current;
+        const nextSelections = curSelections.map((sel) => {
+            const target = sel.head;
+            const nextLine = Math.max(0, Math.min(lines.length - 1, target.line + deltaLine));
+            const lineText = lines[nextLine] || "";
+            let nextCol = Math.max(0, Math.min(lineText.length, target.column + deltaCol));
+            // Never park the caret between the halves of a surrogate pair.
+            if (deltaCol < 0 && nextCol > 0 && nextCol < lineText.length) {
+                if (isTrailSurrogate(lineText.charCodeAt(nextCol)) &&
+                    isLeadSurrogate(lineText.charCodeAt(nextCol - 1))) {
+                    nextCol -= 1;
+                }
+            }
+            else if (deltaCol > 0 && nextCol > 0 && nextCol < lineText.length) {
+                if (isLeadSurrogate(lineText.charCodeAt(nextCol - 1)) &&
+                    isTrailSurrogate(lineText.charCodeAt(nextCol))) {
+                    nextCol += 1;
+                }
+            }
+            const nextHead = { line: nextLine, column: nextCol };
+            const nextAnchor = select ? sel.anchor : nextHead;
+            return { anchor: nextAnchor, head: nextHead };
+        });
+        updateSelections(nextSelections);
+    }, [lines, updateSelections]);
+    const moveByWord = useCallback((direction, select = false) => {
+        const curSelections = selectionsRef.current;
+        const nextSelections = curSelections.map((sel) => {
+            const target = sel.head;
+            const lineText = lines[target.line] || "";
+            let nextCol = findWordBoundary(lineText, target.column, direction);
+            let nextLine = target.line;
+            if (direction === -1 && target.column === 0 && target.line > 0) {
+                nextLine = target.line - 1;
+                const prevLineText = lines[nextLine] || "";
+                nextCol = prevLineText.length;
+            }
+            else if (direction === 1 &&
+                target.column === lineText.length &&
+                target.line < lines.length - 1) {
+                nextLine = target.line + 1;
+                nextCol = 0;
+            }
+            const nextHead = { line: nextLine, column: nextCol };
+            const nextAnchor = select ? sel.anchor : nextHead;
+            return { anchor: nextAnchor, head: nextHead };
+        });
+        updateSelections(nextSelections);
+    }, [lines, updateSelections]);
+    const moveToLineEdge = useCallback((edge, select = false) => {
+        const curSelections = selectionsRef.current;
+        const nextSelections = curSelections.map((sel) => {
+            const target = sel.head;
+            const lineText = lines[target.line] || "";
+            let nextCol = 0;
+            if (edge === "start") {
+                const firstNonWs = lineText.search(/\S/);
+                const indentCol = firstNonWs === -1 ? 0 : firstNonWs;
+                if (target.column === indentCol) {
+                    nextCol = 0;
+                }
+                else {
+                    nextCol = indentCol;
+                }
+            }
+            else {
+                nextCol = lineText.length;
+            }
+            const nextHead = { line: target.line, column: nextCol };
+            const nextAnchor = select ? sel.anchor : nextHead;
+            return { anchor: nextAnchor, head: nextHead };
+        });
+        updateSelections(nextSelections);
+    }, [lines, updateSelections]);
+    const moveByPage = useCallback((direction, select = false) => {
+        const PAGE_SIZE = 25;
+        moveCursor(direction * PAGE_SIZE, 0, select);
+    }, [moveCursor]);
+    const toggleComment = useCallback((commentPrefix = "// ") => {
+        setLines((prevLines) => {
+            const curSelections = selectionsRef.current;
+            pushUndo(prevLines, curSelections);
+            let minLine = prevLines.length;
+            let maxLine = 0;
+            for (const s of curSelections) {
+                const norm = normalizeSelection(s);
+                if (norm.start.line < minLine)
+                    minLine = norm.start.line;
+                if (norm.end.line > maxLine)
+                    maxLine = norm.end.line;
+            }
+            if (minLine > maxLine) {
+                minLine = cursorRef.current.line;
+                maxLine = cursorRef.current.line;
+            }
+            const { newLines } = toggleLinesComment(prevLines, minLine, maxLine, commentPrefix);
+            setIsDirty(true);
+            onChange?.(newLines.join("\n"));
+            return newLines;
+        });
+    }, [pushUndo, onChange]);
+    const setCursor = useCallback((pos, preserveSelection = false) => {
+        const lineIdx = Math.max(0, Math.min(lines.length - 1, pos.line));
+        const lineLen = lines[lineIdx]?.length || 0;
+        const col = Math.max(0, Math.min(lineLen, pos.column));
+        const clampedPos = { line: lineIdx, column: col };
+        if (preserveSelection) {
+            const prim = selectionsRef.current[0];
+            updateSelections([{ anchor: prim ? prim.anchor : clampedPos, head: clampedPos }]);
+        }
+        else {
+            updateSelections([{ anchor: clampedPos, head: clampedPos }]);
+        }
+    }, [lines, updateSelections]);
+    const selectAll = useCallback(() => {
+        if (lines.length === 0)
+            return;
+        const lastLineIdx = lines.length - 1;
+        const lastCol = lines[lastLineIdx].length;
+        updateSelections([
+            {
+                anchor: { line: 0, column: 0 },
+                head: { line: lastLineIdx, column: lastCol },
+            },
+        ]);
+    }, [lines, updateSelections]);
+    const selectNextOccurrence = useCallback(() => {
+        const curSelections = selectionsRef.current;
+        if (curSelections.length === 0)
+            return;
+        if (curSelections.length === 1 && isSelectionCollapsed(curSelections[0])) {
+            const head = curSelections[0].head;
+            const lineText = lines[head.line] || "";
+            const wordRange = getWordRangeAt(lineText, head.line, head.column);
+            if (wordRange.start.line !== wordRange.end.line ||
+                wordRange.start.column !== wordRange.end.column) {
+                updateSelections([{ anchor: wordRange.start, head: wordRange.end }]);
+            }
+            return;
+        }
+        const prim = curSelections[0];
+        const query = getTextInRange(lines, normalizeSelection(prim));
+        if (!query)
+            return;
+        const fullText = lines.join("\n");
+        const existingOffsets = new Set();
+        for (const sel of curSelections) {
+            const norm = normalizeSelection(sel);
+            existingOffsets.add(positionToOffset(lines, norm.start));
+        }
+        const lastSel = curSelections[curSelections.length - 1];
+        const lastNorm = normalizeSelection(lastSel);
+        const lastEndOffset = positionToOffset(lines, lastNorm.end);
+        let matchIdx = fullText.indexOf(query, lastEndOffset);
+        if (matchIdx === -1) {
+            matchIdx = fullText.indexOf(query, 0);
+        }
+        let attempts = 0;
+        while (matchIdx !== -1 && existingOffsets.has(matchIdx) && attempts < fullText.length) {
+            matchIdx = fullText.indexOf(query, matchIdx + 1);
+            if (matchIdx === -1 && lastEndOffset > 0) {
+                matchIdx = fullText.indexOf(query, 0);
+            }
+            attempts++;
+        }
+        if (matchIdx !== -1 && !existingOffsets.has(matchIdx)) {
+            const matchStart = offsetToPosition(lines, matchIdx);
+            const matchEnd = offsetToPosition(lines, matchIdx + query.length);
+            updateSelections([...curSelections, { anchor: matchStart, head: matchEnd }]);
+        }
+    }, [lines, updateSelections]);
+    const selectAllOccurrences = useCallback(() => {
+        let curSelections = selectionsRef.current;
+        if (curSelections.length === 0)
+            return;
+        if (curSelections.length === 1 && isSelectionCollapsed(curSelections[0])) {
+            const head = curSelections[0].head;
+            const lineText = lines[head.line] || "";
+            const wordRange = getWordRangeAt(lineText, head.line, head.column);
+            if (wordRange.start.line === wordRange.end.line &&
+                wordRange.start.column === wordRange.end.column) {
+                return;
+            }
+            curSelections = [{ anchor: wordRange.start, head: wordRange.end }];
+        }
+        const prim = curSelections[0];
+        const query = getTextInRange(lines, normalizeSelection(prim));
+        if (!query)
+            return;
+        const fullText = lines.join("\n");
+        const newSelections = [];
+        let idx = fullText.indexOf(query, 0);
+        while (idx !== -1) {
+            const matchStart = offsetToPosition(lines, idx);
+            const matchEnd = offsetToPosition(lines, idx + query.length);
+            newSelections.push({ anchor: matchStart, head: matchEnd });
+            idx = fullText.indexOf(query, idx + query.length);
+        }
+        if (newSelections.length > 0) {
+            updateSelections(newSelections);
+        }
+    }, [lines, updateSelections]);
+    const [ghostText, setGhostText] = useState(null);
+    const ghostTextRef = useRef(null);
+    ghostTextRef.current = ghostText;
+    const acceptGhostText = useCallback((mode = "full") => {
+        const ghost = ghostTextRef.current;
+        if (!ghost)
+            return;
+        const cur = cursorRef.current;
+        if (ghost.position.line !== cur.line || ghost.position.column !== cur.column) {
+            setGhostText(null);
+            return;
+        }
+        if (mode === "full") {
+            insertText(ghost.text);
+            setGhostText(null);
+        }
+        else {
+            const match = ghost.text.match(/^(\s*\w+|\s*\W+)/);
+            if (match) {
+                const chunk = match[0];
+                insertText(chunk);
+                const remaining = ghost.text.slice(chunk.length);
+                if (remaining.length > 0) {
+                    setGhostText({
+                        text: remaining,
+                        position: { line: cur.line, column: cur.column + chunk.length },
+                    });
+                }
+                else {
+                    setGhostText(null);
+                }
+            }
+            else {
+                insertText(ghost.text);
+                setGhostText(null);
+            }
+        }
+    }, [insertText]);
+    const setColumnSelection = useCallback((start, end) => {
+        const cols = computeColumnSelection(lines, start, end);
+        if (cols.length > 0) {
+            updateSelections(cols);
+        }
+    }, [lines, updateSelections]);
+    const applyCodeAction = useCallback((action) => {
+        if (!action.changes || action.changes.length === 0)
+            return;
+        setLines((prevLines) => {
+            pushUndo(prevLines, selectionsRef.current);
+            let fullText = prevLines.join("\n");
+            const sortedChanges = [...(action.changes || [])].sort((a, b) => b.from - a.from);
+            for (const change of sortedChanges) {
+                fullText = fullText.slice(0, change.from) + change.insert + fullText.slice(change.to);
+            }
+            const nextLines = fullText.split(/\r?\n/);
+            setIsDirty(true);
+            onChange?.(fullText);
+            return nextLines;
+        });
+    }, [pushUndo, onChange]);
+    const undo = useCallback(() => {
+        setGhostText(null);
+        const prev = undoStack.current.pop();
+        if (!prev)
+            return;
+        redoStack.current.push({ lines, selections: selectionsRef.current });
+        setLines(prev.lines);
+        updateSelections(prev.selections);
+        onChange?.(prev.lines.join("\n"));
+    }, [lines, updateSelections, onChange]);
+    const redo = useCallback(() => {
+        setGhostText(null);
+        const next = redoStack.current.pop();
+        if (!next)
+            return;
+        undoStack.current.push({ lines, selections: selectionsRef.current });
+        setLines(next.lines);
+        updateSelections(next.selections);
+        onChange?.(next.lines.join("\n"));
+    }, [lines, updateSelections, onChange]);
+    const value = {
+        adapter,
+        lines,
+        totalLines: lines.length,
+        cursor,
+        selection,
+        selections,
+        ghostText,
+        setGhostText,
+        acceptGhostText,
+        setColumnSelection,
+        applyCodeAction,
+        isDirty,
+        canUndo: undoStack.current.length > 0,
+        canRedo: redoStack.current.length > 0,
+        visibleRange,
+        insertText,
+        deleteSelectionOrChar,
+        enter,
+        tab,
+        moveCursor,
+        moveByWord,
+        moveToLineEdge,
+        moveByPage,
+        toggleComment,
+        autoCloseOrWrap,
+        setCursor,
+        setSelection,
+        setSelections,
+        addCursor,
+        selectNextOccurrence,
+        selectAllOccurrences,
+        clearSecondaryCursors,
+        selectAll,
+        setVisibleRange: (startLine, lineCount) => setVisibleRange({ startLine, lineCount }),
+        undo,
+        redo,
+        getContent,
+        getAdapterContent,
+        tier: adapter ? "adapter" : "memory",
+        snapshot: adapter ? snapshot : null,
+        setContent,
+        replaceContent,
+    };
+    return _jsx(EditorContext.Provider, { value: value, children: children });
+}
+export function useEditorContext() {
+    const ctx = useContext(EditorContext);
+    if (!ctx) {
+        throw new Error("useEditorContext must be used within an <EditorProvider />");
+    }
+    return ctx;
+}
+//# sourceMappingURL=EditorContext.js.map