fss-link 1.0.40 → 1.0.45

package/dist/ui/components/shared/vim-buffer-actions.ts

@@ -0,0 +1,814 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  TextBufferState,
+  TextBufferAction,
+  getLineRangeOffsets,
+  getPositionFromOffsets,
+  replaceRangeInternal,
+  pushUndo,
+  isWordCharStrict,
+  isWordCharWithCombining,
+  isCombiningMark,
+  findNextWordAcrossLines,
+  findPrevWordAcrossLines,
+  findWordEndInLine,
+} from './text-buffer.js';
+import { cpLen, toCodePoints } from '../../utils/textUtils.js';
+import { assumeExhaustive } from '../../../utils/checks.js';
+
+// Check if we're at the end of a base word (on the last base character)
+// Returns true if current position has a base character followed only by combining marks until non-word
+function isAtEndOfBaseWord(lineCodePoints: string[], col: number): boolean {
+  if (!isWordCharStrict(lineCodePoints[col])) return false;
+
+  // Look ahead to see if we have only combining marks followed by non-word
+  let i = col + 1;
+
+  // Skip any combining marks
+  while (i < lineCodePoints.length && isCombiningMark(lineCodePoints[i])) {
+    i++;
+  }
+
+  // If we hit end of line or non-word character, we were at end of base word
+  return i >= lineCodePoints.length || !isWordCharStrict(lineCodePoints[i]);
+}
+
+export type VimAction = Extract<
+  TextBufferAction,
+  | { type: 'vim_delete_word_forward' }
+  | { type: 'vim_delete_word_backward' }
+  | { type: 'vim_delete_word_end' }
+  | { type: 'vim_change_word_forward' }
+  | { type: 'vim_change_word_backward' }
+  | { type: 'vim_change_word_end' }
+  | { type: 'vim_delete_line' }
+  | { type: 'vim_change_line' }
+  | { type: 'vim_delete_to_end_of_line' }
+  | { type: 'vim_change_to_end_of_line' }
+  | { type: 'vim_change_movement' }
+  | { type: 'vim_move_left' }
+  | { type: 'vim_move_right' }
+  | { type: 'vim_move_up' }
+  | { type: 'vim_move_down' }
+  | { type: 'vim_move_word_forward' }
+  | { type: 'vim_move_word_backward' }
+  | { type: 'vim_move_word_end' }
+  | { type: 'vim_delete_char' }
+  | { type: 'vim_insert_at_cursor' }
+  | { type: 'vim_append_at_cursor' }
+  | { type: 'vim_open_line_below' }
+  | { type: 'vim_open_line_above' }
+  | { type: 'vim_append_at_line_end' }
+  | { type: 'vim_insert_at_line_start' }
+  | { type: 'vim_move_to_line_start' }
+  | { type: 'vim_move_to_line_end' }
+  | { type: 'vim_move_to_first_nonwhitespace' }
+  | { type: 'vim_move_to_first_line' }
+  | { type: 'vim_move_to_last_line' }
+  | { type: 'vim_move_to_line' }
+  | { type: 'vim_escape_insert_mode' }
+>;
+
+export function handleVimAction(
+  state: TextBufferState,
+  action: VimAction,
+): TextBufferState {
+  const { lines, cursorRow, cursorCol } = state;
+
+  switch (action.type) {
+    case 'vim_delete_word_forward':
+    case 'vim_change_word_forward': {
+      const { count } = action.payload;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const nextWord = findNextWordAcrossLines(lines, endRow, endCol, true);
+        if (nextWord) {
+          endRow = nextWord.row;
+          endCol = nextWord.col;
+        } else {
+          // No more words, delete/change to end of current word or line
+          const currentLine = lines[endRow] || '';
+          const wordEnd = findWordEndInLine(currentLine, endCol);
+          if (wordEnd !== null) {
+            endCol = wordEnd + 1; // Include the character at word end
+          } else {
+            endCol = cpLen(currentLine);
+          }
+          break;
+        }
+      }
+
+      if (endRow !== cursorRow || endCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          endRow,
+          endCol,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_delete_word_backward':
+    case 'vim_change_word_backward': {
+      const { count } = action.payload;
+      let startRow = cursorRow;
+      let startCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const prevWord = findPrevWordAcrossLines(lines, startRow, startCol);
+        if (prevWord) {
+          startRow = prevWord.row;
+          startCol = prevWord.col;
+        } else {
+          break;
+        }
+      }
+
+      if (startRow !== cursorRow || startCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          startRow,
+          startCol,
+          cursorRow,
+          cursorCol,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_delete_word_end':
+    case 'vim_change_word_end': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          endRow = wordEnd.row;
+          endCol = wordEnd.col + 1; // Include the character at word end
+          // For next iteration, move to start of next word
+          if (i < count - 1) {
+            const nextWord = findNextWordAcrossLines(
+              lines,
+              wordEnd.row,
+              wordEnd.col + 1,
+              true,
+            );
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+            } else {
+              break; // No more words
+            }
+          }
+        } else {
+          break;
+        }
+      }
+
+      // Ensure we don't go past the end of the last line
+      if (endRow < lines.length) {
+        const lineLen = cpLen(lines[endRow] || '');
+        endCol = Math.min(endCol, lineLen);
+      }
+
+      if (endRow !== cursorRow || endCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          endRow,
+          endCol,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_delete_line': {
+      const { count } = action.payload;
+      if (lines.length === 0) return state;
+
+      const linesToDelete = Math.min(count, lines.length - cursorRow);
+      const totalLines = lines.length;
+
+      if (totalLines === 1 || linesToDelete >= totalLines) {
+        // If there's only one line, or we're deleting all remaining lines,
+        // clear the content but keep one empty line (text editors should never be completely empty)
+        const nextState = pushUndo(state);
+        return {
+          ...nextState,
+          lines: [''],
+          cursorRow: 0,
+          cursorCol: 0,
+          preferredCol: null,
+        };
+      }
+
+      const nextState = pushUndo(state);
+      const newLines = [...nextState.lines];
+      newLines.splice(cursorRow, linesToDelete);
+
+      // Adjust cursor position
+      const newCursorRow = Math.min(cursorRow, newLines.length - 1);
+      const newCursorCol = 0; // Vim places cursor at beginning of line after dd
+
+      return {
+        ...nextState,
+        lines: newLines,
+        cursorRow: newCursorRow,
+        cursorCol: newCursorCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_change_line': {
+      const { count } = action.payload;
+      if (lines.length === 0) return state;
+
+      const linesToChange = Math.min(count, lines.length - cursorRow);
+      const nextState = pushUndo(state);
+
+      const { startOffset, endOffset } = getLineRangeOffsets(
+        cursorRow,
+        linesToChange,
+        nextState.lines,
+      );
+      const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
+        startOffset,
+        endOffset,
+        nextState.lines,
+      );
+      return replaceRangeInternal(
+        nextState,
+        startRow,
+        startCol,
+        endRow,
+        endCol,
+        '',
+      );
+    }
+
+    case 'vim_delete_to_end_of_line':
+    case 'vim_change_to_end_of_line': {
+      const currentLine = lines[cursorRow] || '';
+      if (cursorCol < cpLen(currentLine)) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          cursorRow,
+          cpLen(currentLine),
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_change_movement': {
+      const { movement, count } = action.payload;
+      const totalLines = lines.length;
+
+      switch (movement) {
+        case 'h': {
+          // Left
+          // Change N characters to the left
+          const startCol = Math.max(0, cursorCol - count);
+          return replaceRangeInternal(
+            pushUndo(state),
+            cursorRow,
+            startCol,
+            cursorRow,
+            cursorCol,
+            '',
+          );
+        }
+
+        case 'j': {
+          // Down
+          const linesToChange = Math.min(count, totalLines - cursorRow);
+          if (linesToChange > 0) {
+            if (totalLines === 1) {
+              const currentLine = state.lines[0] || '';
+              return replaceRangeInternal(
+                pushUndo(state),
+                0,
+                0,
+                0,
+                cpLen(currentLine),
+                '',
+              );
+            } else {
+              const nextState = pushUndo(state);
+              const { startOffset, endOffset } = getLineRangeOffsets(
+                cursorRow,
+                linesToChange,
+                nextState.lines,
+              );
+              const { startRow, startCol, endRow, endCol } =
+                getPositionFromOffsets(startOffset, endOffset, nextState.lines);
+              return replaceRangeInternal(
+                nextState,
+                startRow,
+                startCol,
+                endRow,
+                endCol,
+                '',
+              );
+            }
+          }
+          return state;
+        }
+
+        case 'k': {
+          // Up
+          const upLines = Math.min(count, cursorRow + 1);
+          if (upLines > 0) {
+            if (state.lines.length === 1) {
+              const currentLine = state.lines[0] || '';
+              return replaceRangeInternal(
+                pushUndo(state),
+                0,
+                0,
+                0,
+                cpLen(currentLine),
+                '',
+              );
+            } else {
+              const startRow = Math.max(0, cursorRow - count + 1);
+              const linesToChange = cursorRow - startRow + 1;
+              const nextState = pushUndo(state);
+              const { startOffset, endOffset } = getLineRangeOffsets(
+                startRow,
+                linesToChange,
+                nextState.lines,
+              );
+              const {
+                startRow: newStartRow,
+                startCol,
+                endRow,
+                endCol,
+              } = getPositionFromOffsets(
+                startOffset,
+                endOffset,
+                nextState.lines,
+              );
+              const resultState = replaceRangeInternal(
+                nextState,
+                newStartRow,
+                startCol,
+                endRow,
+                endCol,
+                '',
+              );
+              return {
+                ...resultState,
+                cursorRow: startRow,
+                cursorCol: 0,
+              };
+            }
+          }
+          return state;
+        }
+
+        case 'l': {
+          // Right
+          // Change N characters to the right
+          return replaceRangeInternal(
+            pushUndo(state),
+            cursorRow,
+            cursorCol,
+            cursorRow,
+            Math.min(cpLen(lines[cursorRow] || ''), cursorCol + count),
+            '',
+          );
+        }
+
+        default:
+          return state;
+      }
+    }
+
+    case 'vim_move_left': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      let newRow = cursorRow;
+      let newCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        if (newCol > 0) {
+          newCol--;
+        } else if (newRow > 0) {
+          // Move to end of previous line
+          newRow--;
+          const prevLine = lines[newRow] || '';
+          const prevLineLength = cpLen(prevLine);
+          // Position on last character, or column 0 for empty lines
+          newCol = prevLineLength === 0 ? 0 : prevLineLength - 1;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_right': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      let newRow = cursorRow;
+      let newCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const currentLine = lines[newRow] || '';
+        const lineLength = cpLen(currentLine);
+        // Don't move past the last character of the line
+        // For empty lines, stay at column 0; for non-empty lines, don't go past last character
+        if (lineLength === 0) {
+          // Empty line - try to move to next line
+          if (newRow < lines.length - 1) {
+            newRow++;
+            newCol = 0;
+          }
+        } else if (newCol < lineLength - 1) {
+          newCol++;
+
+          // Skip over combining marks - don't let cursor land on them
+          const currentLinePoints = toCodePoints(currentLine);
+          while (
+            newCol < currentLinePoints.length &&
+            isCombiningMark(currentLinePoints[newCol]) &&
+            newCol < lineLength - 1
+          ) {
+            newCol++;
+          }
+        } else if (newRow < lines.length - 1) {
+          // At end of line - move to beginning of next line
+          newRow++;
+          newCol = 0;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_up': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const newRow = Math.max(0, cursorRow - count);
+      const targetLine = lines[newRow] || '';
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(
+        cursorCol,
+        targetLineLength > 0 ? targetLineLength - 1 : 0,
+      );
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_down': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const newRow = Math.min(lines.length - 1, cursorRow + count);
+      const targetLine = lines[newRow] || '';
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(
+        cursorCol,
+        targetLineLength > 0 ? targetLineLength - 1 : 0,
+      );
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_word_forward': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const nextWord = findNextWordAcrossLines(lines, row, col, true);
+        if (nextWord) {
+          row = nextWord.row;
+          col = nextWord.col;
+        } else {
+          // No more words to move to
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_word_backward': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const prevWord = findPrevWordAcrossLines(lines, row, col);
+        if (prevWord) {
+          row = prevWord.row;
+          col = prevWord.col;
+        } else {
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_word_end': {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        // Special handling for the first iteration when we're at end of word
+        if (i === 0) {
+          const currentLine = lines[row] || '';
+          const lineCodePoints = toCodePoints(currentLine);
+
+          // Check if we're at the end of a word (on the last base character)
+          const atEndOfWord =
+            col < lineCodePoints.length &&
+            isWordCharStrict(lineCodePoints[col]) &&
+            (col + 1 >= lineCodePoints.length ||
+              !isWordCharWithCombining(lineCodePoints[col + 1]) ||
+              // Or if we're on a base char followed only by combining marks until non-word
+              (isWordCharStrict(lineCodePoints[col]) &&
+                isAtEndOfBaseWord(lineCodePoints, col)));
+
+          if (atEndOfWord) {
+            // We're already at end of word, find next word end
+            const nextWord = findNextWordAcrossLines(
+              lines,
+              row,
+              col + 1,
+              false,
+            );
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+              continue;
+            }
+          }
+        }
+
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          row = wordEnd.row;
+          col = wordEnd.col;
+        } else {
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_delete_char': {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      const lineLength = cpLen(currentLine);
+
+      if (cursorCol < lineLength) {
+        const deleteCount = Math.min(count, lineLength - cursorCol);
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          cursorRow,
+          cursorCol + deleteCount,
+          '',
+        );
+      }
+      return state;
+    }
+
+    case 'vim_insert_at_cursor': {
+      // Just return state - mode change is handled elsewhere
+      return state;
+    }
+
+    case 'vim_append_at_cursor': {
+      const { cursorRow, cursorCol, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      const newCol = cursorCol < cpLen(currentLine) ? cursorCol + 1 : cursorCol;
+
+      return {
+        ...state,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_open_line_below': {
+      const { cursorRow, lines } = state;
+      const nextState = pushUndo(state);
+
+      // Insert newline at end of current line
+      const endOfLine = cpLen(lines[cursorRow] || '');
+      return replaceRangeInternal(
+        nextState,
+        cursorRow,
+        endOfLine,
+        cursorRow,
+        endOfLine,
+        '\n',
+      );
+    }
+
+    case 'vim_open_line_above': {
+      const { cursorRow } = state;
+      const nextState = pushUndo(state);
+
+      // Insert newline at beginning of current line
+      const resultState = replaceRangeInternal(
+        nextState,
+        cursorRow,
+        0,
+        cursorRow,
+        0,
+        '\n',
+      );
+
+      // Move cursor to the new line above
+      return {
+        ...resultState,
+        cursorRow,
+        cursorCol: 0,
+      };
+    }
+
+    case 'vim_append_at_line_end': {
+      const { cursorRow, lines } = state;
+      const lineLength = cpLen(lines[cursorRow] || '');
+
+      return {
+        ...state,
+        cursorCol: lineLength,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_insert_at_line_start': {
+      const { cursorRow, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      let col = 0;
+
+      // Find first non-whitespace character using proper Unicode handling
+      const lineCodePoints = toCodePoints(currentLine);
+      while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
+        col++;
+      }
+
+      return {
+        ...state,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_line_start': {
+      return {
+        ...state,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_line_end': {
+      const { cursorRow, lines } = state;
+      const lineLength = cpLen(lines[cursorRow] || '');
+
+      return {
+        ...state,
+        cursorCol: lineLength > 0 ? lineLength - 1 : 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_first_nonwhitespace': {
+      const { cursorRow, lines } = state;
+      const currentLine = lines[cursorRow] || '';
+      let col = 0;
+
+      // Find first non-whitespace character using proper Unicode handling
+      const lineCodePoints = toCodePoints(currentLine);
+      while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
+        col++;
+      }
+
+      return {
+        ...state,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_first_line': {
+      return {
+        ...state,
+        cursorRow: 0,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_last_line': {
+      const { lines } = state;
+      const lastRow = lines.length - 1;
+
+      return {
+        ...state,
+        cursorRow: lastRow,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_move_to_line': {
+      const { lineNumber } = action.payload;
+      const { lines } = state;
+      const targetRow = Math.min(Math.max(0, lineNumber - 1), lines.length - 1);
+
+      return {
+        ...state,
+        cursorRow: targetRow,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case 'vim_escape_insert_mode': {
+      // Move cursor left if not at beginning of line (vim behavior when exiting insert mode)
+      const { cursorCol } = state;
+      const newCol = cursorCol > 0 ? cursorCol - 1 : 0;
+
+      return {
+        ...state,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    default: {
+      // This should never happen if TypeScript is working correctly
+      assumeExhaustive(action);
+      return state;
+    }
+  }
+}