@sunub/obsidian-mcp-server 0.3.19 → 0.3.21

package/build/cli/key/text-buffer.js

@@ -0,0 +1,937 @@
+import { LRU_BUFFER_PERF_CACHE_LIMIT } from "../constants.js";
+import { cpLen, cpSlice, getCachedStringWidth, toCodePoints, } from "../utils/textUtil.js";
+import { LRUCache } from "mnemonist";
+import { useCallback, useEffect, useMemo, useReducer } from "react";
+export const PASTED_TEXT_PLACEHOLDER_REGEX = /\[Pasted Text: \d+ (?:lines|chars)(?: #\d+)?\]/g;
+const lineLayoutCache = new LRUCache(LRU_BUFFER_PERF_CACHE_LIMIT);
+function getLineLayoutCacheKey(line, viewportWidth, isCursorOnLine, cursorCol) {
+    // Most lines (99.9% in a large buffer) are not cursor lines.
+    // We use a simpler key for them to reduce string allocation overhead.
+    if (!isCursorOnLine) {
+        return `${viewportWidth}:N:${line}`;
+    }
+    return `${viewportWidth}:C:${cursorCol}:${line}`;
+}
+function calculateVisualCursorFromLayout(layout, logicalCursor) {
+    const { logicalToVisualMap, visualLines, transformedToLogicalMaps } = layout;
+    const [logicalRow, logicalCol] = logicalCursor;
+    const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
+    if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) {
+        // This can happen for an empty document.
+        return [0, 0, 0];
+    }
+    // Find the segment where the logical column fits.
+    // The segments are sorted by startColInLogical.
+    let targetSegmentIndex = segmentsForLogicalLine.findIndex(([, startColInLogical], index) => {
+        const nextStartColInLogical = index + 1 < segmentsForLogicalLine.length
+            ? segmentsForLogicalLine[index + 1][1]
+            : Infinity;
+        return (logicalCol >= startColInLogical && logicalCol < nextStartColInLogical);
+    });
+    // If not found, it means the cursor is at the end of the logical line.
+    if (targetSegmentIndex === -1) {
+        if (logicalCol === 0) {
+            targetSegmentIndex = 0;
+        }
+        else {
+            targetSegmentIndex = segmentsForLogicalLine.length - 1;
+        }
+    }
+    const [visualRow, startColInLogical] = segmentsForLogicalLine[targetSegmentIndex];
+    // Find the coordinates in transformed space in order to conver to visual
+    const transformedToLogicalMap = transformedToLogicalMaps[logicalRow] ?? [];
+    let transformedCol = 0;
+    for (let i = 0; i < transformedToLogicalMap.length; i++) {
+        if (transformedToLogicalMap[i] > logicalCol) {
+            transformedCol = Math.max(0, i - 1);
+            break;
+        }
+        if (i === transformedToLogicalMap.length - 1) {
+            transformedCol = transformedToLogicalMap.length - 1;
+        }
+    }
+    let startColInTransformed = 0;
+    while (startColInTransformed < transformedToLogicalMap.length &&
+        transformedToLogicalMap[startColInTransformed] < startColInLogical) {
+        startColInTransformed++;
+    }
+    const clampedTransformedCol = Math.min(transformedCol, Math.max(0, transformedToLogicalMap.length - 1));
+    const visualColIndex = clampedTransformedCol - startColInTransformed;
+    const currentVisualLineText = visualLines[visualRow] ?? "";
+    let visualColWidth = 0;
+    const codePoints = toCodePoints(currentVisualLineText);
+    for (let i = 0; i < Math.min(visualColIndex, codePoints.length); i++) {
+        visualColWidth += getCachedStringWidth(codePoints[i]);
+    }
+    const clampedVisualColIndex = Math.min(Math.max(visualColIndex, 0), codePoints.length);
+    return [visualRow, clampedVisualColIndex, visualColWidth];
+}
+/**
+ * Helper: Converts logical row/col position to absolute text offset
+ */
+export function logicalPosToOffset(lines, row, col) {
+    let offset = 0;
+    const actualRow = Math.min(row, lines.length - 1);
+    for (let i = 0; i < actualRow; i++) {
+        offset += cpLen(lines[i]) + 1; // +1 for newline
+    }
+    if (actualRow >= 0 && actualRow < lines.length) {
+        offset += Math.min(col, cpLen(lines[actualRow]));
+    }
+    return offset;
+}
+/**
+ * Helper: Converts absolute text offset to logical row/col position
+ */
+export function offsetToLogicalPos(text, offset) {
+    const lines = text.split("\n");
+    let currentOffset = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lineLen = cpLen(lines[i]);
+        const lineLenWithNewline = lineLen + (i < lines.length - 1 ? 1 : 0);
+        if (offset <= currentOffset + lineLen) {
+            return [i, offset - currentOffset];
+        }
+        if (offset < currentOffset + lineLenWithNewline) {
+            return [i, lineLen];
+        }
+        currentOffset += lineLenWithNewline;
+    }
+    const lastRow = Math.max(0, lines.length - 1);
+    return [lastRow, cpLen(lines[lastRow] || "")];
+}
+function bufferReducerLogic(state, action) {
+    const { lines, cursorRow, cursorCol } = state;
+    const currentLineText = lines[cursorRow] || "";
+    const lineCount = lines.length;
+    const pushUndo = (_newLines) => {
+        return [...state.undoStack, lines].slice(-100);
+    };
+    switch (action.type) {
+        case "SET_VIEWPORT":
+            return {
+                ...state,
+                viewportWidth: action.payload.width,
+                viewportHeight: action.payload.height,
+            };
+        case "SET_TEXT": {
+            const newLines = action.payload.replace(/\r\n/g, "\n").split("\n");
+            const safeLines = newLines.length > 0 ? newLines : [""];
+            let r = 0;
+            let c = 0;
+            if (action.cursorPosition === "end") {
+                r = safeLines.length - 1;
+                c = cpLen(safeLines[r]);
+            }
+            else if (typeof action.cursorPosition === "number") {
+                [r, c] = offsetToLogicalPos(action.payload, action.cursorPosition);
+            }
+            return {
+                ...state,
+                lines: safeLines,
+                cursorRow: r,
+                cursorCol: c,
+                preferredCol: null,
+                undoStack: pushUndo(safeLines),
+                redoStack: [],
+            };
+        }
+        case "INSERT": {
+            const payload = action.payload
+                .replace(/\r\n/g, "\n")
+                .replace(/\r/g, "\n");
+            const parts = payload.split("\n");
+            const newLines = [...lines];
+            const before = cpSlice(currentLineText, 0, cursorCol);
+            const after = cpSlice(currentLineText, cursorCol);
+            let nextRow = cursorRow;
+            let nextCol = cursorCol;
+            if (parts.length === 1) {
+                newLines[cursorRow] = before + parts[0] + after;
+                nextCol = cursorCol + cpLen(parts[0]);
+            }
+            else {
+                const firstLine = before + parts[0];
+                const lastPart = parts[parts.length - 1];
+                const lastLine = lastPart + after;
+                const middle = parts.slice(1, -1);
+                newLines.splice(cursorRow, 1, firstLine, ...middle, lastLine);
+                nextRow = cursorRow + parts.length - 1;
+                nextCol = cpLen(lastPart);
+            }
+            return {
+                ...state,
+                lines: newLines,
+                cursorRow: nextRow,
+                cursorCol: nextCol,
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "NEWLINE": {
+            const newLines = [...lines];
+            const before = cpSlice(currentLineText, 0, cursorCol);
+            const after = cpSlice(currentLineText, cursorCol);
+            newLines[cursorRow] = before;
+            newLines.splice(cursorRow + 1, 0, after);
+            return {
+                ...state,
+                lines: newLines,
+                cursorRow: cursorRow + 1,
+                cursorCol: 0,
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "BACKSPACE": {
+            if (cursorCol === 0 && cursorRow === 0)
+                return state;
+            const newLines = [...lines];
+            if (cursorCol > 0) {
+                newLines[cursorRow] =
+                    cpSlice(currentLineText, 0, cursorCol - 1) +
+                        cpSlice(currentLineText, cursorCol);
+                return {
+                    ...state,
+                    lines: newLines,
+                    cursorCol: cursorCol - 1,
+                    preferredCol: null,
+                    undoStack: pushUndo(newLines),
+                    redoStack: [],
+                };
+            }
+            else {
+                const prevLine = lines[cursorRow - 1];
+                const prevLen = cpLen(prevLine);
+                newLines[cursorRow - 1] = prevLine + currentLineText;
+                newLines.splice(cursorRow, 1);
+                return {
+                    ...state,
+                    lines: newLines,
+                    cursorRow: cursorRow - 1,
+                    cursorCol: prevLen,
+                    preferredCol: null,
+                    undoStack: pushUndo(newLines),
+                    redoStack: [],
+                };
+            }
+        }
+        case "DELETE": {
+            if (cursorCol === cpLen(currentLineText) && cursorRow === lineCount - 1)
+                return state;
+            const newLines = [...lines];
+            if (cursorCol < cpLen(currentLineText)) {
+                newLines[cursorRow] =
+                    cpSlice(currentLineText, 0, cursorCol) +
+                        cpSlice(currentLineText, cursorCol + 1);
+            }
+            else {
+                newLines[cursorRow] = currentLineText + lines[cursorRow + 1];
+                newLines.splice(cursorRow + 1, 1);
+            }
+            return {
+                ...state,
+                lines: newLines,
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "KILL_LINE_RIGHT": {
+            const newLines = [...lines];
+            newLines[cursorRow] = cpSlice(currentLineText, 0, cursorCol);
+            return {
+                ...state,
+                lines: newLines,
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "KILL_LINE_LEFT": {
+            const newLines = [...lines];
+            newLines[cursorRow] = cpSlice(currentLineText, cursorCol);
+            return {
+                ...state,
+                lines: newLines,
+                cursorCol: 0,
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "DELETE_WORD_LEFT": {
+            if (cursorCol === 0)
+                return state;
+            const before = cpSlice(currentLineText, 0, cursorCol);
+            const after = cpSlice(currentLineText, cursorCol);
+            // Simple word boundary: skip whitespace then skip non-whitespace
+            let i = before.length - 1;
+            while (i >= 0 && before[i] === " ")
+                i--;
+            while (i >= 0 && before[i] !== " ")
+                i--;
+            const newBefore = before.slice(0, i + 1);
+            const newLines = [...lines];
+            newLines[cursorRow] = newBefore + after;
+            return {
+                ...state,
+                lines: newLines,
+                cursorCol: cpLen(newBefore),
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "DELETE_WORD_RIGHT": {
+            const before = cpSlice(currentLineText, 0, cursorCol);
+            const after = cpSlice(currentLineText, cursorCol);
+            if (after.length === 0)
+                return state;
+            let i = 0;
+            while (i < after.length && after[i] === " ")
+                i++;
+            while (i < after.length && after[i] !== " ")
+                i++;
+            const newAfter = after.slice(i);
+            const newLines = [...lines];
+            newLines[cursorRow] = before + newAfter;
+            return {
+                ...state,
+                lines: newLines,
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "MOVE": {
+            const { dir } = action;
+            const { visualLayout, preferredCol } = state;
+            const [vRow, , vWidth] = calculateVisualCursorFromLayout(visualLayout, [
+                cursorRow,
+                cursorCol,
+            ]);
+            if (dir === "left" ||
+                dir === "right" ||
+                dir === "home" ||
+                dir === "end") {
+                let r = cursorRow;
+                let c = cursorCol;
+                if (dir === "left") {
+                    if (c > 0)
+                        c--;
+                    else if (r > 0) {
+                        r--;
+                        c = cpLen(lines[r]);
+                    }
+                }
+                else if (dir === "right") {
+                    if (c < cpLen(currentLineText))
+                        c++;
+                    else if (r < lineCount - 1) {
+                        r++;
+                        c = 0;
+                    }
+                }
+                else if (dir === "home")
+                    c = 0;
+                else if (dir === "end")
+                    c = cpLen(currentLineText);
+                return { ...state, cursorRow: r, cursorCol: c, preferredCol: null };
+            }
+            // Up/Down movement (width-based)
+            let newVisRow = vRow;
+            const targetWidth = preferredCol !== null ? preferredCol : vWidth;
+            if (dir === "up" && newVisRow > 0) {
+                newVisRow--;
+            }
+            else if (dir === "down" &&
+                newVisRow < visualLayout.visualLines.length - 1) {
+                newVisRow++;
+            }
+            else {
+                return state;
+            }
+            // Find the logical index in the new visual line that best matches the targetWidth
+            const newLineText = visualLayout.visualLines[newVisRow] ?? "";
+            const codePoints = toCodePoints(newLineText);
+            let currentWidth = 0;
+            let newVisColIdx = 0;
+            for (let i = 0; i < codePoints.length; i++) {
+                const charWidth = getCachedStringWidth(codePoints[i]);
+                if (currentWidth + charWidth > targetWidth) {
+                    break;
+                }
+                currentWidth += charWidth;
+                newVisColIdx = i + 1;
+            }
+            const mapping = visualLayout.visualToLogicalMap[newVisRow];
+            if (mapping) {
+                return {
+                    ...state,
+                    cursorRow: mapping[0],
+                    cursorCol: mapping[1] + newVisColIdx,
+                    preferredCol: targetWidth,
+                };
+            }
+            return state;
+        }
+        case "REPLACE_RANGE": {
+            const { startRow, startCol, endRow, endCol, text } = action.payload;
+            const newLines = [...lines];
+            const prefix = cpSlice(lines[startRow] || "", 0, startCol);
+            const suffix = cpSlice(lines[endRow] || "", endCol);
+            const replacementParts = text.replace(/\r\n/g, "\n").split("\n");
+            const firstPart = prefix + replacementParts[0];
+            const lastPart = replacementParts[replacementParts.length - 1] + suffix;
+            if (replacementParts.length === 1) {
+                newLines.splice(startRow, endRow - startRow + 1, firstPart + suffix);
+            }
+            else {
+                const middleParts = replacementParts.slice(1, -1);
+                newLines.splice(startRow, endRow - startRow + 1, firstPart, ...middleParts, lastPart);
+            }
+            return {
+                ...state,
+                lines: newLines,
+                cursorRow: startRow + replacementParts.length - 1,
+                cursorCol: cpLen(replacementParts[replacementParts.length - 1]),
+                preferredCol: null,
+                undoStack: pushUndo(newLines),
+                redoStack: [],
+            };
+        }
+        case "UNDO": {
+            if (state.undoStack.length === 0)
+                return state;
+            const prevLines = state.undoStack[state.undoStack.length - 1];
+            return {
+                ...state,
+                lines: prevLines,
+                undoStack: state.undoStack.slice(0, -1),
+                redoStack: [...state.redoStack, lines],
+                cursorRow: Math.max(0, prevLines.length - 1),
+                cursorCol: cpLen(prevLines[prevLines.length - 1] || ""),
+                preferredCol: null,
+            };
+        }
+        case "REDO": {
+            if (state.redoStack.length === 0)
+                return state;
+            const nextLines = state.redoStack[state.redoStack.length - 1];
+            return {
+                ...state,
+                lines: nextLines,
+                redoStack: state.redoStack.slice(0, -1),
+                undoStack: [...state.undoStack, lines],
+                cursorRow: Math.max(0, nextLines.length - 1),
+                cursorCol: cpLen(nextLines[nextLines.length - 1] || ""),
+                preferredCol: null,
+            };
+        }
+        default:
+            return state;
+    }
+}
+const transformationsCache = new LRUCache(LRU_BUFFER_PERF_CACHE_LIMIT);
+export function calculateTransformationsForLine(line) {
+    const cached = transformationsCache.get(line);
+    if (cached) {
+        return cached;
+    }
+    const transformations = [];
+    // 2. Detect paste placeholders
+    const pasteRegex = new RegExp(PASTED_TEXT_PLACEHOLDER_REGEX.source, "g");
+    const match = pasteRegex.exec(line);
+    while (match !== null) {
+        const logicalText = match[0];
+        const logStart = cpLen(line.substring(0, match.index));
+        const logEnd = logStart + cpLen(logicalText);
+        transformations.push({
+            logStart,
+            logEnd,
+            logicalText,
+            collapsedText: logicalText,
+            type: "paste",
+            id: logicalText,
+        });
+    }
+    // Sort transformations by logStart to maintain consistency
+    transformations.sort((a, b) => a.logStart - b.logStart);
+    transformationsCache.set(line, transformations);
+    return transformations;
+}
+export function calculateTransformedLine(logLine, logIndex, logicalCursor, transformations) {
+    let transformedLine = "";
+    const transformedToLogMap = [];
+    let lastLogPos = 0;
+    const cursorIsOnThisLine = logIndex === logicalCursor[0];
+    const cursorCol = logicalCursor[1];
+    for (const transform of transformations) {
+        const textBeforeTransformation = cpSlice(logLine, lastLogPos, transform.logStart);
+        transformedLine += textBeforeTransformation;
+        for (let i = 0; i < cpLen(textBeforeTransformation); i++) {
+            transformedToLogMap.push(lastLogPos + i);
+        }
+        const isExpanded = transform.type === "image" &&
+            cursorIsOnThisLine &&
+            cursorCol >= transform.logStart &&
+            cursorCol <= transform.logEnd;
+        const transformedText = isExpanded
+            ? transform.logicalText
+            : transform.collapsedText;
+        transformedLine += transformedText;
+        // Map transformed characters back to logical characters
+        const transformedLen = cpLen(transformedText);
+        if (isExpanded) {
+            for (let i = 0; i < transformedLen; i++) {
+                transformedToLogMap.push(transform.logStart + i);
+            }
+        }
+        else {
+            // Collapsed: distribute transformed positions monotonically across the raw span.
+            // This preserves ordering across wrapped slices so logicalToVisualMap has
+            // increasing startColInLogical and visual cursor mapping remains consistent.
+            const logicalLength = Math.max(0, transform.logEnd - transform.logStart);
+            for (let i = 0; i < transformedLen; i++) {
+                // Map the i-th transformed code point into [logStart, logEnd)
+                const transformationToLogicalOffset = logicalLength === 0
+                    ? 0
+                    : Math.floor((i * logicalLength) / transformedLen);
+                const transformationToLogicalIndex = transform.logStart +
+                    Math.min(transformationToLogicalOffset, Math.max(logicalLength - 1, 0));
+                transformedToLogMap.push(transformationToLogicalIndex);
+            }
+        }
+        lastLogPos = transform.logEnd;
+    }
+    // Append text after last transform
+    const remainingUntransformedText = cpSlice(logLine, lastLogPos);
+    transformedLine += remainingUntransformedText;
+    for (let i = 0; i < cpLen(remainingUntransformedText); i++) {
+        transformedToLogMap.push(lastLogPos + i);
+    }
+    // For a cursor at the very end of the transformed line
+    transformedToLogMap.push(cpLen(logLine));
+    return { transformedLine, transformedToLogMap };
+}
+function calculateLayout(logicalLines, viewportWidth, logicalCursor) {
+    const visualLines = [];
+    const logicalToVisualMap = [];
+    const visualToLogicalMap = [];
+    const transformedToLogicalMaps = [];
+    const visualToTransformedMap = [];
+    logicalLines.forEach((logLine, logIndex) => {
+        logicalToVisualMap[logIndex] = [];
+        const isCursorOnLine = logIndex === logicalCursor[0];
+        const cacheKey = getLineLayoutCacheKey(logLine, viewportWidth, isCursorOnLine, logicalCursor[1]);
+        const cached = lineLayoutCache.get(cacheKey);
+        if (cached) {
+            const visualLineOffset = visualLines.length;
+            visualLines.push(...cached.visualLines);
+            cached.logicalToVisualMap.forEach(([relVisualIdx, logCol]) => {
+                logicalToVisualMap[logIndex].push([
+                    visualLineOffset + relVisualIdx,
+                    logCol,
+                ]);
+            });
+            cached.visualToLogicalMap.forEach(([, logCol]) => {
+                visualToLogicalMap.push([logIndex, logCol]);
+            });
+            transformedToLogicalMaps[logIndex] = cached.transformedToLogMap;
+            visualToTransformedMap.push(...cached.visualToTransformedMap);
+            return;
+        }
+        // Not in cache, calculate
+        const transformations = calculateTransformationsForLine(logLine);
+        const { transformedLine, transformedToLogMap } = calculateTransformedLine(logLine, logIndex, logicalCursor, transformations);
+        const lineVisualLines = [];
+        const lineLogicalToVisualMap = [];
+        const lineVisualToLogicalMap = [];
+        const lineVisualToTransformedMap = [];
+        if (transformedLine.length === 0) {
+            // Handle empty logical line
+            lineLogicalToVisualMap.push([0, 0]);
+            lineVisualToLogicalMap.push([logIndex, 0]);
+            lineVisualToTransformedMap.push(0);
+            lineVisualLines.push("");
+        }
+        else {
+            // Non-empty logical line
+            let currentPosInLogLine = 0; // Tracks position within the current logical line (code point index)
+            const codePointsInLogLine = toCodePoints(transformedLine);
+            while (currentPosInLogLine < codePointsInLogLine.length) {
+                let currentChunk = "";
+                let currentChunkVisualWidth = 0;
+                let numCodePointsInChunk = 0;
+                let lastWordBreakPoint = -1; // Index in codePointsInLogLine for word break
+                let numCodePointsAtLastWordBreak = 0;
+                // Iterate through code points to build the current visual line (chunk)
+                for (let i = currentPosInLogLine; i < codePointsInLogLine.length; i++) {
+                    const char = codePointsInLogLine[i];
+                    const charVisualWidth = getCachedStringWidth(char);
+                    if (currentChunkVisualWidth + charVisualWidth > viewportWidth) {
+                        // Character would exceed viewport width
+                        if (lastWordBreakPoint !== -1 &&
+                            numCodePointsAtLastWordBreak > 0 &&
+                            currentPosInLogLine + numCodePointsAtLastWordBreak < i) {
+                            // We have a valid word break point to use, and it's not the start of the current segment
+                            currentChunk = codePointsInLogLine
+                                .slice(currentPosInLogLine, currentPosInLogLine + numCodePointsAtLastWordBreak)
+                                .join("");
+                            numCodePointsInChunk = numCodePointsAtLastWordBreak;
+                        }
+                        else {
+                            // No word break, or word break is at the start of this potential chunk, or word break leads to empty chunk.
+                            // Hard break: take characters up to viewportWidth, or just the current char if it alone is too wide.
+                            if (numCodePointsInChunk === 0 &&
+                                charVisualWidth > viewportWidth) {
+                                // Single character is wider than viewport, take it anyway
+                                currentChunk = char;
+                                numCodePointsInChunk = 1;
+                            }
+                        }
+                        break; // Break from inner loop to finalize this chunk
+                    }
+                    currentChunk += char;
+                    currentChunkVisualWidth += charVisualWidth;
+                    numCodePointsInChunk++;
+                    // Check for word break opportunity (space)
+                    if (char === " ") {
+                        lastWordBreakPoint = i; // Store code point index of the space
+                        // Store the state *before* adding the space, if we decide to break here.
+                        numCodePointsAtLastWordBreak = numCodePointsInChunk - 1; // Chars *before* the space
+                    }
+                }
+                if (numCodePointsInChunk === 0 &&
+                    currentPosInLogLine < codePointsInLogLine.length) {
+                    const firstChar = codePointsInLogLine[currentPosInLogLine];
+                    currentChunk = firstChar;
+                    numCodePointsInChunk = 1;
+                }
+                const logicalStartCol = transformedToLogMap[currentPosInLogLine] ?? 0;
+                lineLogicalToVisualMap.push([lineVisualLines.length, logicalStartCol]);
+                lineVisualToLogicalMap.push([logIndex, logicalStartCol]);
+                lineVisualToTransformedMap.push(currentPosInLogLine);
+                lineVisualLines.push(currentChunk);
+                const logicalStartOfThisChunk = currentPosInLogLine;
+                currentPosInLogLine += numCodePointsInChunk;
+                if (logicalStartOfThisChunk + numCodePointsInChunk <
+                    codePointsInLogLine.length &&
+                    currentPosInLogLine < codePointsInLogLine.length &&
+                    codePointsInLogLine[currentPosInLogLine] === " ") {
+                    currentPosInLogLine++;
+                }
+            }
+        }
+        // Cache the result for this line
+        lineLayoutCache.set(cacheKey, {
+            visualLines: lineVisualLines,
+            logicalToVisualMap: lineLogicalToVisualMap,
+            visualToLogicalMap: lineVisualToLogicalMap,
+            transformedToLogMap,
+            visualToTransformedMap: lineVisualToTransformedMap,
+        });
+        const visualLineOffset = visualLines.length;
+        visualLines.push(...lineVisualLines);
+        lineLogicalToVisualMap.forEach(([relVisualIdx, logCol]) => {
+            logicalToVisualMap[logIndex].push([
+                visualLineOffset + relVisualIdx,
+                logCol,
+            ]);
+        });
+        lineVisualToLogicalMap.forEach(([, logCol]) => {
+            visualToLogicalMap.push([logIndex, logCol]);
+        });
+        transformedToLogicalMaps[logIndex] = transformedToLogMap;
+        visualToTransformedMap.push(...lineVisualToTransformedMap);
+    });
+    // If the entire logical text was empty, ensure there's one empty visual line.
+    if (logicalLines.length === 0 ||
+        (logicalLines.length === 1 && logicalLines[0] === "")) {
+        if (visualLines.length === 0) {
+            visualLines.push("");
+            if (!logicalToVisualMap[0])
+                logicalToVisualMap[0] = [];
+            logicalToVisualMap[0].push([0, 0]);
+            visualToLogicalMap.push([0, 0]);
+            visualToTransformedMap.push(0);
+        }
+    }
+    return {
+        visualLines,
+        logicalToVisualMap,
+        visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+    };
+}
+function textBufferReducer(state, action) {
+    let newState = bufferReducerLogic(state, action);
+    // Recalculate layout if lines or width changed
+    if (newState.lines !== state.lines ||
+        newState.viewportWidth !== state.viewportWidth) {
+        newState = {
+            ...newState,
+            visualLayout: calculateLayout(newState.lines, newState.viewportWidth, [
+                newState.cursorRow,
+                newState.cursorCol,
+            ]),
+        };
+    }
+    // Handle scrolling (Vertical scroll-into-view)
+    const visualCursor = calculateVisualCursorFromLayout(newState.visualLayout, [
+        newState.cursorRow,
+        newState.cursorCol,
+    ]);
+    const cursorVisRow = visualCursor[0];
+    let newScrollRow = newState.visualScrollRow;
+    if (cursorVisRow < newScrollRow) {
+        newScrollRow = cursorVisRow;
+    }
+    else if (cursorVisRow >= newScrollRow + newState.viewportHeight) {
+        newScrollRow = cursorVisRow - newState.viewportHeight + 1;
+    }
+    // Clamp scroll row
+    const maxScroll = Math.max(0, newState.visualLayout.visualLines.length - newState.viewportHeight);
+    newScrollRow = Math.min(Math.max(newScrollRow, 0), maxScroll);
+    if (newScrollRow !== newState.visualScrollRow) {
+        newState = { ...newState, visualScrollRow: newScrollRow };
+    }
+    return newState;
+}
+export function useTextBuffer({ initialText = "", viewportWidth = 80, viewportHeight = 10, }) {
+    const initialState = useMemo(() => {
+        const lines = initialText.replace(/\r\n/g, "\n").split("\n");
+        const safeLines = lines.length === 0 ? [""] : lines;
+        const layout = calculateLayout(safeLines, viewportWidth, [0, 0]);
+        return {
+            lines: safeLines,
+            cursorRow: 0,
+            cursorCol: 0,
+            preferredCol: null,
+            undoStack: [],
+            redoStack: [],
+            viewportWidth,
+            viewportHeight,
+            visualScrollRow: 0,
+            visualLayout: layout,
+        };
+    }, [initialText, viewportWidth, viewportHeight]);
+    const [state, dispatch] = useReducer(textBufferReducer, initialState);
+    useEffect(() => {
+        dispatch({
+            type: "SET_VIEWPORT",
+            payload: { width: viewportWidth, height: viewportHeight },
+        });
+    }, [viewportWidth, viewportHeight]);
+    const insert = useCallback((text, opts) => dispatch({ type: "INSERT", payload: text, isPaste: opts?.paste }), []);
+    const setText = useCallback((text, cursorPosition) => dispatch({ type: "SET_TEXT", payload: text, cursorPosition }), []);
+    const backspace = useCallback(() => dispatch({ type: "BACKSPACE" }), []);
+    const deleteChar = useCallback(() => dispatch({ type: "DELETE" }), []);
+    const newline = useCallback(() => dispatch({ type: "NEWLINE" }), []);
+    const killLineRight = useCallback(() => dispatch({ type: "KILL_LINE_RIGHT" }), []);
+    const killLineLeft = useCallback(() => dispatch({ type: "KILL_LINE_LEFT" }), []);
+    const deleteWordLeft = useCallback(() => dispatch({ type: "DELETE_WORD_LEFT" }), []);
+    const deleteWordRight = useCallback(() => dispatch({ type: "DELETE_WORD_RIGHT" }), []);
+    const move = useCallback((dir) => dispatch({ type: "MOVE", dir }), []);
+    const undo = useCallback(() => dispatch({ type: "UNDO" }), []);
+    const redo = useCallback(() => dispatch({ type: "REDO" }), []);
+    const replaceRange = useCallback((startRow, startCol, endRow, endCol, text) => dispatch({
+        type: "REPLACE_RANGE",
+        payload: { startRow, startCol, endRow, endCol, text },
+    }), []);
+    const getOffset = useCallback(() => logicalPosToOffset(state.lines, state.cursorRow, state.cursorCol), [state.lines, state.cursorRow, state.cursorCol]);
+    const handleInput = useCallback((key) => {
+        if (key.name === "backspace") {
+            backspace();
+            return true;
+        }
+        if (key.name === "delete") {
+            deleteChar();
+            return true;
+        }
+        if (key.name === "left") {
+            move("left");
+            return true;
+        }
+        if (key.name === "right") {
+            move("right");
+            return true;
+        }
+        if (key.name === "up") {
+            move("up");
+            return true;
+        }
+        if (key.name === "down") {
+            move("down");
+            return true;
+        }
+        if (key.name === "home") {
+            move("home");
+            return true;
+        }
+        if (key.name === "end") {
+            move("end");
+            return true;
+        }
+        if (key.name === "enter" && key.shift) {
+            newline();
+            return true;
+        }
+        // Handle character input (only insertable printable characters)
+        if (key.insertable && key.sequence) {
+            insert(key.sequence);
+            return true;
+        }
+        return false;
+    }, [backspace, deleteChar, move, insert, newline]);
+    const [vRow, vColIdx, vWidth] = useMemo(() => calculateVisualCursorFromLayout(state.visualLayout, [
+        state.cursorRow,
+        state.cursorCol,
+    ]), [state.visualLayout, state.cursorRow, state.cursorCol]);
+    const visualCursor = useMemo(() => [vRow, vWidth], [vRow, vWidth]);
+    const visualCursorColIndex = vColIdx;
+    const viewportVisualLines = useMemo(() => state.visualLayout.visualLines.slice(state.visualScrollRow, state.visualScrollRow + state.viewportHeight), [
+        state.visualLayout.visualLines,
+        state.visualScrollRow,
+        state.viewportHeight,
+    ]);
+    const noop = useCallback(() => { }, []);
+    const noopCount = useCallback((_count) => { }, []);
+    const noopAsync = useCallback(async () => { }, []);
+    return useMemo(() => ({
+        lines: state.lines,
+        text: state.lines.join("\n"),
+        cursor: [state.cursorRow, state.cursorCol],
+        preferredCol: state.preferredCol,
+        selectionAnchor: null,
+        pastedContent: {},
+        // Visual / Viewport properties
+        allVisualLines: state.visualLayout.visualLines,
+        viewportVisualLines,
+        visualCursor,
+        visualCursorColIndex,
+        visualCursorColWidth: vWidth,
+        visualScrollRow: state.visualScrollRow,
+        viewportHeight: state.viewportHeight,
+        visualToLogicalMap: state.visualLayout.visualToLogicalMap,
+        transformedToLogicalMaps: state.visualLayout.transformedToLogicalMaps,
+        visualToTransformedMap: state.visualLayout.visualToTransformedMap,
+        visualLayout: state.visualLayout,
+        // Core actions
+        insert,
+        setText,
+        newline,
+        backspace,
+        del: deleteChar,
+        move,
+        undo,
+        redo,
+        replaceRange,
+        deleteWordLeft,
+        deleteWordRight,
+        killLineRight,
+        killLineLeft,
+        handleInput,
+        getOffset,
+        // Advanced actions (stubs — not yet implemented in this buffer)
+        openInExternalEditor: noopAsync,
+        replaceRangeByOffset: (_s, _e, _t) => { },
+        moveToOffset: (_offset) => { },
+        moveToVisualPosition: (_vr, _vc) => { },
+        getLogicalPositionFromVisual: (_vr, _vc) => null,
+        getExpandedPasteAtLine: (_lineIndex) => null,
+        togglePasteExpansion: (_id, _row, _col) => { },
+        // Vim stubs
+        vimDeleteWordForward: noopCount,
+        vimDeleteWordBackward: noopCount,
+        vimDeleteWordEnd: noopCount,
+        vimDeleteBigWordForward: noopCount,
+        vimDeleteBigWordBackward: noopCount,
+        vimDeleteBigWordEnd: noopCount,
+        vimChangeWordForward: noopCount,
+        vimChangeWordBackward: noopCount,
+        vimChangeWordEnd: noopCount,
+        vimChangeBigWordForward: noopCount,
+        vimChangeBigWordBackward: noopCount,
+        vimChangeBigWordEnd: noopCount,
+        vimDeleteLine: noopCount,
+        vimChangeLine: noopCount,
+        vimDeleteToEndOfLine: (_count) => { },
+        vimDeleteToStartOfLine: noop,
+        vimChangeToEndOfLine: (_count) => { },
+        vimDeleteToFirstNonWhitespace: noop,
+        vimChangeToStartOfLine: noop,
+        vimChangeToFirstNonWhitespace: noop,
+        vimDeleteToFirstLine: noopCount,
+        vimDeleteToLastLine: noopCount,
+        vimChangeMovement: (_m, _count) => { },
+        vimMoveLeft: noopCount,
+        vimMoveRight: noopCount,
+        vimMoveUp: noopCount,
+        vimMoveDown: noopCount,
+        vimMoveWordForward: noopCount,
+        vimMoveWordBackward: noopCount,
+        vimMoveWordEnd: noopCount,
+        vimMoveBigWordForward: noopCount,
+        vimMoveBigWordBackward: noopCount,
+        vimMoveBigWordEnd: noopCount,
+        vimDeleteChar: noopCount,
+        vimDeleteCharBefore: noopCount,
+        vimToggleCase: noopCount,
+        vimReplaceChar: (_char, _count) => { },
+        vimFindCharForward: (_char, _count, _till) => { },
+        vimFindCharBackward: (_char, _count, _till) => { },
+        vimDeleteToCharForward: (_char, _count, _till) => { },
+        vimDeleteToCharBackward: (_char, _count, _till) => { },
+        vimInsertAtCursor: noop,
+        vimAppendAtCursor: noop,
+        vimOpenLineBelow: noop,
+        vimOpenLineAbove: noop,
+        vimAppendAtLineEnd: noop,
+        vimInsertAtLineStart: noop,
+        vimMoveToLineStart: noop,
+        vimMoveToLineEnd: noop,
+        vimMoveToFirstNonWhitespace: noop,
+        vimMoveToFirstLine: noop,
+        vimMoveToLastLine: noop,
+        vimMoveToLine: noopCount,
+        vimEscapeInsertMode: noop,
+        vimYankLine: noopCount,
+        vimYankWordForward: noopCount,
+        vimYankBigWordForward: noopCount,
+        vimYankWordEnd: noopCount,
+        vimYankBigWordEnd: noopCount,
+        vimYankToEndOfLine: noopCount,
+        vimPasteAfter: noopCount,
+        vimPasteBefore: noopCount,
+    }), [
+        state,
+        viewportVisualLines,
+        visualCursor,
+        visualCursorColIndex,
+        vWidth,
+        insert,
+        setText,
+        newline,
+        backspace,
+        deleteChar,
+        move,
+        undo,
+        redo,
+        replaceRange,
+        deleteWordLeft,
+        deleteWordRight,
+        killLineRight,
+        killLineLeft,
+        handleInput,
+        getOffset,
+        noop,
+        noopCount,
+        noopAsync,
+    ]);
+}
+//# sourceMappingURL=text-buffer.js.map