@rdmind/rdmind 0.0.15-alpha.1 → 0.0.15-alpha.2

package/dist/src/ui/components/shared/text-buffer.js

@@ -8,9 +8,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import pathMod from 'node:path';
 import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
-import stringWidth from 'string-width';
 import { unescapePath } from '@rdmind/rdmind-core';
-import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, } from '../../utils/textUtils.js';
+import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, getCachedStringWidth, } from '../../utils/textUtils.js';
 import { handleVimAction } from './vim-buffer-actions.js';
 // Simple helper for word‑wise ops.
 function isWordChar(ch) {
@@ -455,12 +454,12 @@ export function logicalPosToOffset(lines, row, col) {
     }
     return offset;
 }
-// Helper to calculate visual lines and map cursor positions
-function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
+// Calculates the visual wrapping of lines and the mapping between logical and visual coordinates.
+// This is an expensive operation and should be memoized.
+function calculateLayout(logicalLines, viewportWidth) {
     const visualLines = [];
     const logicalToVisualMap = [];
     const visualToLogicalMap = [];
-    let currentVisualCursor = [0, 0];
     logicalLines.forEach((logLine, logIndex) => {
         logicalToVisualMap[logIndex] = [];
         if (logLine.length === 0) {
@@ -468,9 +467,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
             logicalToVisualMap[logIndex].push([visualLines.length, 0]);
             visualToLogicalMap.push([logIndex, 0]);
             visualLines.push('');
-            if (logIndex === logicalCursor[0] && logicalCursor[1] === 0) {
-                currentVisualCursor = [visualLines.length - 1, 0];
-            }
         }
         else {
             // Non-empty logical line
@@ -485,7 +481,7 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                 // 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 = stringWidth(char);
+                    const charVisualWidth = getCachedStringWidth(char);
                     if (currentChunkVisualWidth + charVisualWidth > viewportWidth) {
                         // Character would exceed viewport width
                         if (lastWordBreakPoint !== -1 &&
@@ -551,27 +547,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                 ]);
                 visualToLogicalMap.push([logIndex, currentPosInLogLine]);
                 visualLines.push(currentChunk);
-                // Cursor mapping logic
-                // Note: currentPosInLogLine here is the start of the currentChunk within the logical line.
-                if (logIndex === logicalCursor[0]) {
-                    const cursorLogCol = logicalCursor[1]; // This is a code point index
-                    if (cursorLogCol >= currentPosInLogLine &&
-                        cursorLogCol < currentPosInLogLine + numCodePointsInChunk // Cursor is within this chunk
-                    ) {
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            cursorLogCol - currentPosInLogLine, // Visual col is also code point index within visual line
-                        ];
-                    }
-                    else if (cursorLogCol === currentPosInLogLine + numCodePointsInChunk &&
-                        numCodePointsInChunk > 0) {
-                        // Cursor is exactly at the end of this non-empty chunk
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            numCodePointsInChunk,
-                        ];
-                    }
-                }
                 const logicalStartOfThisChunk = currentPosInLogLine;
                 currentPosInLogLine += numCodePointsInChunk;
                 // If the chunk processed did not consume the entire logical line,
@@ -584,20 +559,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                     currentPosInLogLine++;
                 }
             }
-            // After all chunks of a non-empty logical line are processed,
-            // if the cursor is at the very end of this logical line, update visual cursor.
-            if (logIndex === logicalCursor[0] &&
-                logicalCursor[1] === codePointsInLogLine.length // Cursor at end of logical line
-            ) {
-                const lastVisualLineIdx = visualLines.length - 1;
-                if (lastVisualLineIdx >= 0 &&
-                    visualLines[lastVisualLineIdx] !== undefined) {
-                    currentVisualCursor = [
-                        lastVisualLineIdx,
-                        cpLen(visualLines[lastVisualLineIdx]), // Cursor at end of last visual line for this logical line
-                    ];
-                }
-            }
         }
     });
     // If the entire logical text was empty, ensure there's one empty visual line.
@@ -610,23 +571,46 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
             logicalToVisualMap[0].push([0, 0]);
             visualToLogicalMap.push([0, 0]);
         }
-        currentVisualCursor = [0, 0];
-    }
-    // Handle cursor at the very end of the text (after all processing)
-    // This case might be covered by the loop end condition now, but kept for safety.
-    else if (logicalCursor[0] === logicalLines.length - 1 &&
-        logicalCursor[1] === cpLen(logicalLines[logicalLines.length - 1]) &&
-        visualLines.length > 0) {
-        const lastVisLineIdx = visualLines.length - 1;
-        currentVisualCursor = [lastVisLineIdx, cpLen(visualLines[lastVisLineIdx])];
     }
     return {
         visualLines,
-        visualCursor: currentVisualCursor,
         logicalToVisualMap,
         visualToLogicalMap,
     };
 }
+// Calculates the visual cursor position based on a pre-calculated layout.
+// This is a lightweight operation.
+function calculateVisualCursorFromLayout(layout, logicalCursor) {
+    const { logicalToVisualMap, visualLines } = layout;
+    const [logicalRow, logicalCol] = logicalCursor;
+    const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
+    if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) {
+        // This can happen for an empty document.
+        return [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];
+    const visualCol = logicalCol - startColInLogical;
+    // The visual column should not exceed the length of the visual line.
+    const clampedVisualCol = Math.min(visualCol, cpLen(visualLines[visualRow] ?? ''));
+    return [visualRow, clampedVisualCol];
+}
 const historyLimit = 100;
 export const pushUndo = (currentState) => {
     const snapshot = {
@@ -640,7 +624,7 @@ export const pushUndo = (currentState) => {
     }
     return { ...currentState, undoStack: newStack, redoStack: [] };
 };
-export function textBufferReducer(state, action) {
+function textBufferReducerLogic(state, action) {
     const pushUndoLocal = pushUndo;
     const currentLine = (r) => state.lines[r] ?? '';
     const currentLineLen = (r) => cpLen(currentLine(r));
@@ -727,68 +711,101 @@ export function textBufferReducer(state, action) {
                 preferredCol: null,
             };
         }
-        case 'set_viewport_width': {
-            if (action.payload === state.viewportWidth) {
+        case 'set_viewport': {
+            const { width, height } = action.payload;
+            if (width === state.viewportWidth && height === state.viewportHeight) {
                 return state;
             }
-            return { ...state, viewportWidth: action.payload };
+            return {
+                ...state,
+                viewportWidth: width,
+                viewportHeight: height,
+            };
         }
         case 'move': {
             const { dir } = action.payload;
-            const { lines, cursorRow, cursorCol, viewportWidth } = state;
-            const visualLayout = calculateVisualLayout(lines, [cursorRow, cursorCol], viewportWidth);
-            const { visualLines, visualCursor, visualToLogicalMap } = visualLayout;
-            let newVisualRow = visualCursor[0];
-            let newVisualCol = visualCursor[1];
-            let newPreferredCol = state.preferredCol;
-            const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
-            switch (dir) {
-                case 'left':
-                    newPreferredCol = null;
-                    if (newVisualCol > 0) {
-                        newVisualCol--;
-                    }
-                    else if (newVisualRow > 0) {
-                        newVisualRow--;
-                        newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
-                    }
-                    break;
-                case 'right':
-                    newPreferredCol = null;
-                    if (newVisualCol < currentVisLineLen) {
-                        newVisualCol++;
-                    }
-                    else if (newVisualRow < visualLines.length - 1) {
-                        newVisualRow++;
+            const { cursorRow, cursorCol, lines, visualLayout, preferredCol } = state;
+            // Visual movements
+            if (dir === 'left' ||
+                dir === 'right' ||
+                dir === 'up' ||
+                dir === 'down' ||
+                dir === 'home' ||
+                dir === 'end') {
+                const visualCursor = calculateVisualCursorFromLayout(visualLayout, [
+                    cursorRow,
+                    cursorCol,
+                ]);
+                const { visualLines, visualToLogicalMap } = visualLayout;
+                let newVisualRow = visualCursor[0];
+                let newVisualCol = visualCursor[1];
+                let newPreferredCol = preferredCol;
+                const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
+                switch (dir) {
+                    case 'left':
+                        newPreferredCol = null;
+                        if (newVisualCol > 0) {
+                            newVisualCol--;
+                        }
+                        else if (newVisualRow > 0) {
+                            newVisualRow--;
+                            newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
+                        }
+                        break;
+                    case 'right':
+                        newPreferredCol = null;
+                        if (newVisualCol < currentVisLineLen) {
+                            newVisualCol++;
+                        }
+                        else if (newVisualRow < visualLines.length - 1) {
+                            newVisualRow++;
+                            newVisualCol = 0;
+                        }
+                        break;
+                    case 'up':
+                        if (newVisualRow > 0) {
+                            if (newPreferredCol === null)
+                                newPreferredCol = newVisualCol;
+                            newVisualRow--;
+                            newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
+                        }
+                        break;
+                    case 'down':
+                        if (newVisualRow < visualLines.length - 1) {
+                            if (newPreferredCol === null)
+                                newPreferredCol = newVisualCol;
+                            newVisualRow++;
+                            newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
+                        }
+                        break;
+                    case 'home':
+                        newPreferredCol = null;
                         newVisualCol = 0;
+                        break;
+                    case 'end':
+                        newPreferredCol = null;
+                        newVisualCol = currentVisLineLen;
+                        break;
+                    default: {
+                        const exhaustiveCheck = dir;
+                        console.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
+                        return state;
                     }
-                    break;
-                case 'up':
-                    if (newVisualRow > 0) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow--;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'down':
-                    if (newVisualRow < visualLines.length - 1) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow++;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'home':
-                    newPreferredCol = null;
-                    newVisualCol = 0;
-                    break;
-                case 'end':
-                    newPreferredCol = null;
-                    newVisualCol = currentVisLineLen;
-                    break;
+                }
+                if (visualToLogicalMap[newVisualRow]) {
+                    const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
+                    return {
+                        ...state,
+                        cursorRow: logRow,
+                        cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(lines[logRow] ?? '')),
+                        preferredCol: newPreferredCol,
+                    };
+                }
+                return state;
+            }
+            // Logical movements
+            switch (dir) {
                 case 'wordLeft': {
-                    const { cursorRow, cursorCol, lines } = state;
                     if (cursorCol === 0 && cursorRow === 0)
                         return state;
                     let newCursorRow = cursorRow;
@@ -827,7 +844,6 @@ export function textBufferReducer(state, action) {
                     };
                 }
                 case 'wordRight': {
-                    const { cursorRow, cursorCol, lines } = state;
                     if (cursorRow === lines.length - 1 &&
                         cursorCol === cpLen(lines[cursorRow] ?? '')) {
                         return state;
@@ -856,18 +872,14 @@ export function textBufferReducer(state, action) {
                     };
                 }
                 default:
-                    break;
+                    return state;
             }
-            if (visualToLogicalMap[newVisualRow]) {
-                const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
-                return {
-                    ...state,
-                    cursorRow: logRow,
-                    cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(state.lines[logRow] ?? '')),
-                    preferredCol: newPreferredCol,
-                };
-            }
-            return state;
+        }
+        case 'set_cursor': {
+            return {
+                ...state,
+                ...action.payload,
+            };
         }
         case 'delete': {
             const { cursorRow, cursorCol, lines } = state;
@@ -878,7 +890,11 @@ export function textBufferReducer(state, action) {
                 newLines[cursorRow] =
                     cpSlice(lineContent, 0, cursorCol) +
                         cpSlice(lineContent, cursorCol + 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             else if (cursorRow < lines.length - 1) {
                 const nextState = pushUndoLocal(state);
@@ -886,7 +902,11 @@ export function textBufferReducer(state, action) {
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             return state;
         }
@@ -894,78 +914,62 @@ export function textBufferReducer(state, action) {
             const { cursorRow, cursorCol } = state;
             if (cursorCol === 0 && cursorRow === 0)
                 return state;
-            if (cursorCol === 0) {
+            const nextState = pushUndoLocal(state);
+            const newLines = [...nextState.lines];
+            let newCursorRow = cursorRow;
+            let newCursorCol = cursorCol;
+            if (newCursorCol > 0) {
+                const lineContent = currentLine(newCursorRow);
+                const prevWordStart = findPrevWordStartInLine(lineContent, newCursorCol);
+                const start = prevWordStart === null ? 0 : prevWordStart;
+                newLines[newCursorRow] =
+                    cpSlice(lineContent, 0, start) + cpSlice(lineContent, newCursorCol);
+                newCursorCol = start;
+            }
+            else {
                 // Act as a backspace
-                const nextState = pushUndoLocal(state);
                 const prevLineContent = currentLine(cursorRow - 1);
                 const currentLineContentVal = currentLine(cursorRow);
                 const newCol = cpLen(prevLineContent);
-                const newLines = [...nextState.lines];
                 newLines[cursorRow - 1] = prevLineContent + currentLineContentVal;
                 newLines.splice(cursorRow, 1);
-                return {
-                    ...nextState,
-                    lines: newLines,
-                    cursorRow: cursorRow - 1,
-                    cursorCol: newCol,
-                    preferredCol: null,
-                };
-            }
-            const nextState = pushUndoLocal(state);
-            const lineContent = currentLine(cursorRow);
-            const arr = toCodePoints(lineContent);
-            let start = cursorCol;
-            let onlySpaces = true;
-            for (let i = 0; i < start; i++) {
-                if (isWordChar(arr[i])) {
-                    onlySpaces = false;
-                    break;
-                }
-            }
-            if (onlySpaces && start > 0) {
-                start--;
-            }
-            else {
-                while (start > 0 && !isWordChar(arr[start - 1]))
-                    start--;
-                while (start > 0 && isWordChar(arr[start - 1]))
-                    start--;
+                newCursorRow--;
+                newCursorCol = newCol;
             }
-            const newLines = [...nextState.lines];
-            newLines[cursorRow] =
-                cpSlice(lineContent, 0, start) + cpSlice(lineContent, cursorCol);
             return {
                 ...nextState,
                 lines: newLines,
-                cursorCol: start,
+                cursorRow: newCursorRow,
+                cursorCol: newCursorCol,
                 preferredCol: null,
             };
         }
         case 'delete_word_right': {
             const { cursorRow, cursorCol, lines } = state;
             const lineContent = currentLine(cursorRow);
-            const arr = toCodePoints(lineContent);
-            if (cursorCol >= arr.length && cursorRow === lines.length - 1)
+            const lineLen = cpLen(lineContent);
+            if (cursorCol >= lineLen && cursorRow === lines.length - 1) {
                 return state;
-            if (cursorCol >= arr.length) {
-                // Act as a delete
-                const nextState = pushUndoLocal(state);
+            }
+            const nextState = pushUndoLocal(state);
+            const newLines = [...nextState.lines];
+            if (cursorCol >= lineLen) {
+                // Act as a delete, joining with the next line
                 const nextLineContent = currentLine(cursorRow + 1);
-                const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
             }
-            const nextState = pushUndoLocal(state);
-            let end = cursorCol;
-            while (end < arr.length && !isWordChar(arr[end]))
-                end++;
-            while (end < arr.length && isWordChar(arr[end]))
-                end++;
-            const newLines = [...nextState.lines];
-            newLines[cursorRow] =
-                cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
-            return { ...nextState, lines: newLines, preferredCol: null };
+            else {
+                const nextWordStart = findNextWordStartInLine(lineContent, cursorCol);
+                const end = nextWordStart === null ? lineLen : nextWordStart;
+                newLines[cursorRow] =
+                    cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
+            }
+            return {
+                ...nextState,
+                lines: newLines,
+                preferredCol: null,
+            };
         }
         case 'kill_line_right': {
             const { cursorRow, cursorCol, lines } = state;
@@ -974,7 +978,10 @@ export function textBufferReducer(state, action) {
                 const nextState = pushUndoLocal(state);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
-                return { ...nextState, lines: newLines };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                };
             }
             else if (cursorRow < lines.length - 1) {
                 // Act as a delete
@@ -983,7 +990,11 @@ export function textBufferReducer(state, action) {
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             return state;
         }
@@ -1094,11 +1105,23 @@ export function textBufferReducer(state, action) {
         }
     }
 }
+export function textBufferReducer(state, action) {
+    const newState = textBufferReducerLogic(state, action);
+    if (newState.lines !== state.lines ||
+        newState.viewportWidth !== state.viewportWidth) {
+        return {
+            ...newState,
+            visualLayout: calculateLayout(newState.lines, newState.viewportWidth),
+        };
+    }
+    return newState;
+}
 // --- End of reducer logic ---
 export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, isValidPath, shellModeActive = false, }) {
     const initialState = useMemo(() => {
         const lines = initialText.split('\n');
         const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(lines.length === 0 ? [''] : lines, initialCursorOffset);
+        const visualLayout = calculateLayout(lines.length === 0 ? [''] : lines, viewport.width);
         return {
             lines: lines.length === 0 ? [''] : lines,
             cursorRow: initialCursorRow,
@@ -1109,13 +1132,15 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             clipboard: null,
             selectionAnchor: null,
             viewportWidth: viewport.width,
+            viewportHeight: viewport.height,
+            visualLayout,
         };
-    }, [initialText, initialCursorOffset, viewport.width]);
+    }, [initialText, initialCursorOffset, viewport.width, viewport.height]);
     const [state, dispatch] = useReducer(textBufferReducer, initialState);
-    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor } = state;
+    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, } = state;
     const text = useMemo(() => lines.join('\n'), [lines]);
-    const visualLayout = useMemo(() => calculateVisualLayout(lines, [cursorRow, cursorCol], state.viewportWidth), [lines, cursorRow, cursorCol, state.viewportWidth]);
-    const { visualLines, visualCursor } = visualLayout;
+    const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
+    const { visualLines, visualToLogicalMap } = visualLayout;
     const [visualScrollRow, setVisualScrollRow] = useState(0);
     useEffect(() => {
         if (onChange) {
@@ -1123,11 +1148,16 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         }
     }, [text, onChange]);
     useEffect(() => {
-        dispatch({ type: 'set_viewport_width', payload: viewport.width });
-    }, [viewport.width]);
+        dispatch({
+            type: 'set_viewport',
+            payload: { width: viewport.width, height: viewport.height },
+        });
+    }, [viewport.width, viewport.height]);
     // Update visual scroll (vertical)
     useEffect(() => {
         const { height } = viewport;
+        const totalVisualLines = visualLines.length;
+        const maxScrollStart = Math.max(0, totalVisualLines - height);
         let newVisualScrollRow = visualScrollRow;
         if (visualCursor[0] < visualScrollRow) {
             newVisualScrollRow = visualCursor[0];
@@ -1135,10 +1165,13 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         else if (visualCursor[0] >= visualScrollRow + height) {
             newVisualScrollRow = visualCursor[0] - height + 1;
         }
+        // When the number of visual lines shrinks (e.g., after widening the viewport),
+        // ensure scroll never starts beyond the last valid start so we can render a full window.
+        newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart);
         if (newVisualScrollRow !== visualScrollRow) {
             setVisualScrollRow(newVisualScrollRow);
         }
-    }, [visualCursor, visualScrollRow, viewport]);
+    }, [visualCursor, visualScrollRow, viewport, visualLines.length]);
     const insert = useCallback((ch, { paste = false } = {}) => {
         if (/[\n\r]/.test(ch)) {
             dispatch({ type: 'insert', payload: ch });
@@ -1186,7 +1219,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     }, []);
     const move = useCallback((dir) => {
         dispatch({ type: 'move', payload: { dir } });
-    }, []);
+    }, [dispatch]);
     const undo = useCallback(() => {
         dispatch({ type: 'undo' });
     }, []);
@@ -1404,10 +1437,24 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             backspace();
         else if (key.name === 'delete' || (key.ctrl && key.name === 'd'))
             del();
+        else if (key.ctrl && !key.shift && key.name === 'z')
+            undo();
+        else if (key.ctrl && key.shift && key.name === 'z')
+            redo();
         else if (input && !key.ctrl && !key.meta) {
             insert(input, { paste: key.paste });
         }
-    }, [newline, move, deleteWordLeft, deleteWordRight, backspace, del, insert]);
+    }, [
+        newline,
+        move,
+        deleteWordLeft,
+        deleteWordRight,
+        backspace,
+        del,
+        insert,
+        undo,
+        redo,
+    ]);
     const renderedVisualLines = useMemo(() => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height), [visualLines, visualScrollRow, viewport.height]);
     const replaceRange = useCallback((startRow, startCol, endRow, endCol, text) => {
         dispatch({
@@ -1423,7 +1470,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const moveToOffset = useCallback((offset) => {
         dispatch({ type: 'move_to_offset', payload: { offset } });
     }, []);
-    const returnValue = {
+    const returnValue = useMemo(() => ({
         lines,
         text,
         cursor: [cursorRow, cursorCol],
@@ -1433,6 +1480,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         viewportVisualLines: renderedVisualLines,
         visualCursor,
         visualScrollRow,
+        visualToLogicalMap,
         setText,
         insert,
         newline,
@@ -1483,7 +1531,68 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveToLastLine,
         vimMoveToLine,
         vimEscapeInsertMode,
-    };
+    }), [
+        lines,
+        text,
+        cursorRow,
+        cursorCol,
+        preferredCol,
+        selectionAnchor,
+        visualLines,
+        renderedVisualLines,
+        visualCursor,
+        visualScrollRow,
+        setText,
+        insert,
+        newline,
+        backspace,
+        del,
+        move,
+        undo,
+        redo,
+        replaceRange,
+        replaceRangeByOffset,
+        moveToOffset,
+        deleteWordLeft,
+        deleteWordRight,
+        killLineRight,
+        killLineLeft,
+        handleInput,
+        openInExternalEditor,
+        vimDeleteWordForward,
+        vimDeleteWordBackward,
+        vimDeleteWordEnd,
+        vimChangeWordForward,
+        vimChangeWordBackward,
+        vimChangeWordEnd,
+        vimDeleteLine,
+        vimChangeLine,
+        vimDeleteToEndOfLine,
+        vimChangeToEndOfLine,
+        vimChangeMovement,
+        vimMoveLeft,
+        vimMoveRight,
+        vimMoveUp,
+        vimMoveDown,
+        vimMoveWordForward,
+        vimMoveWordBackward,
+        vimMoveWordEnd,
+        vimDeleteChar,
+        vimInsertAtCursor,
+        vimAppendAtCursor,
+        vimOpenLineBelow,
+        vimOpenLineAbove,
+        vimAppendAtLineEnd,
+        vimInsertAtLineStart,
+        vimMoveToLineStart,
+        vimMoveToLineEnd,
+        vimMoveToFirstNonWhitespace,
+        vimMoveToFirstLine,
+        vimMoveToLastLine,
+        vimMoveToLine,
+        vimEscapeInsertMode,
+        visualToLogicalMap,
+    ]);
     return returnValue;
 }
 //# sourceMappingURL=text-buffer.js.map