Vim enhancements (#353)

* Added register and implement line-wise command execution

* Add count-aware h/l and soft-wrap-aware j/k motions

* Implement Vim word/WORD motions (w/b/e and W/B/E)

- Add w, b, e motions using Vim “word” semantics (punctuation-delimited)
- Add W, B, E motions using Vim “WORD” semantics
(non-punctuation-delimited) - Respect counts (e.g., 3w), direction, and
end-of-line/whitespace edge cases - Match Vim behavior for cursor
placement and motion boundaries

* Implemented vim line motion

0 / ^ / $: line start (column 0), first non-blank, end of line

0 has some issues for now will be fixed later on

* Refactor linewise command handling

* Fixed the cursor issues with vim keyboard

* Supports multi-key motions and refactor parsing

* Added the ge command

* Added file motion

* Added view port motion

* Improvemnts (wip)

* Implement paste actions (p, P)

This commit introduces the `p` (paste after) and `P` (paste before)
actions. These actions paste content from the Vim clipboard into the
editor at the cursor position. The actions correctly handle both
character-wise and linewise pastes, adjusting the cursor position
appropriately after the paste operation.

* Fix operator-only command parsing (wip)

* Implement indent and outdent operators

This commit adds the indent (>) and outdent (<) operators to the Vim
emulator. These operators allow users to increase or decrease the
indentation of selected lines. The indentation level is determined by
the `tabSize` setting.

* Add toggle case action (~)

* Implement character replacement (r) command

This commit implements the character replacement command (r) in Vim
mode. It allows users to replace a single character with another, and
also supports the use of Enter and Tab as replacement characters.

Author: SyedMuzamilM

src/hooks/use-vim-keyboard.ts

@@ -3,8 +3,10 @@ import { create } from "zustand";
 import { subscribeWithSelector } from "zustand/middleware";
 import { EDITOR_CONSTANTS } from "@/constants/editor-constants";
 import type { Position, Range } from "@/types/editor-types";
+import { getLineHeight } from "@/utils/editor-position";
 import { createSelectors } from "@/utils/zustand-selectors";
 import { useBufferStore } from "./buffer-store";
+import { useEditorSettingsStore } from "./editor-settings-store";
 
 // Position Cache Manager
 class PositionCacheManager {
@@ -48,6 +50,31 @@ class PositionCacheManager {
 
 const positionCache = new PositionCacheManager();
 
+const ensureCursorVisible = (position: Position) => {
+  if (typeof window === "undefined") return;
+
+  const viewport = document.querySelector(".editor-viewport") as HTMLDivElement | null;
+  if (!viewport) return;
+
+  const fontSize = useEditorSettingsStore.getState().fontSize;
+  const lineHeight = getLineHeight(fontSize);
+  const targetTop = position.line * lineHeight;
+  const targetBottom = targetTop + lineHeight;
+  const currentScrollTop = viewport.scrollTop;
+  const viewportHeight = viewport.clientHeight || 0;
+
+  if (targetTop < currentScrollTop) {
+    viewport.scrollTop = targetTop;
+  } else if (targetBottom > currentScrollTop + viewportHeight) {
+    viewport.scrollTop = Math.max(0, targetBottom - viewportHeight);
+  }
+
+  const textarea = document.querySelector(".editor-textarea") as HTMLTextAreaElement | null;
+  if (textarea && textarea.scrollTop !== viewport.scrollTop) {
+    textarea.scrollTop = viewport.scrollTop;
+  }
+};
+
 // State Interface
 interface EditorState {
   // Cursor state
@@ -126,6 +153,7 @@ export const useEditorStateStore = createSelectors(
             positionCache.set(activeBufferId, position);
           }
           set({ cursorPosition: position });
+          ensureCursorVisible(position);
         },
         setSelection: (selection) => set({ selection }),
         setDesiredColumn: (column) => set({ desiredColumn: column }),

src/stores/editor-state-store.ts

@@ -19,6 +19,15 @@ interface VimState {
     end: { line: number; column: number } | null;
   };
   visualMode: "char" | "line" | null; // Track visual mode type
+  register: {
+    text: string;
+    isLineWise: boolean;
+  };
+  lastOperation: {
+    type: "command" | "action" | null;
+    keys: string[];
+    count?: number;
+  } | null; // For repeat (.) functionality
 }
 
 const defaultVimState: VimState = {
@@ -34,6 +43,11 @@ const defaultVimState: VimState = {
     end: null,
   },
   visualMode: null,
+  register: {
+    text: "",
+    isLineWise: false,
+  },
+  lastOperation: null,
 };
 
 const useVimStoreBase = create(
@@ -122,6 +136,13 @@ const useVimStoreBase = create(
           });
         },
 
+        setRegister: (text: string, isLineWise: boolean) => {
+          set((state) => {
+            state.register.text = text;
+            state.register.isLineWise = isLineWise;
+          });
+        },
+
         clearLastKey: () => {
           set((state) => {
             state.lastKey = null;
@@ -178,6 +199,23 @@ const useVimStoreBase = create(
               return "NORMAL";
           }
         },
+
+        // Last operation management for repeat functionality
+        setLastOperation: (operation: VimState["lastOperation"]) => {
+          set((state) => {
+            state.lastOperation = operation;
+          });
+        },
+
+        getLastOperation: (): VimState["lastOperation"] => {
+          return get().lastOperation;
+        },
+
+        clearLastOperation: () => {
+          set((state) => {
+            state.lastOperation = null;
+          });
+        },
       },
     })),
   ),

src/stores/vim-store.ts

@@ -0,0 +1,47 @@
+/**
+ * Central registry for all vim actions
+ */
+
+import type { Action } from "../core/types";
+import { pasteAction, pasteBeforeAction } from "./paste-actions";
+import { repeatAction } from "./repeat-action";
+import { replaceAction } from "./replace-action";
+import { toggleCaseAction } from "./toggle-case-action";
+
+/**
+ * Registry of all available actions
+ */
+export const actionRegistry: Record<string, Action> = {
+  p: pasteAction,
+  P: pasteBeforeAction,
+  "~": toggleCaseAction,
+  ".": repeatAction,
+  r: replaceAction,
+};
+
+/**
+ * Get an action by key
+ */
+export const getAction = (key: string): Action | undefined => {
+  return actionRegistry[key];
+};
+
+/**
+ * Check if a key is a registered action
+ */
+export const isAction = (key: string): boolean => {
+  return key in actionRegistry;
+};
+
+/**
+ * Get all action keys
+ */
+export const getActionKeys = (): string[] => {
+  return Object.keys(actionRegistry);
+};
+
+// Re-export actions
+export { pasteAction, pasteBeforeAction } from "./paste-actions";
+export { repeatAction } from "./repeat-action";
+export { createReplaceAction, replaceAction } from "./replace-action";
+export { toggleCaseAction } from "./toggle-case-action";

src/stores/vim/actions/index.ts

@@ -0,0 +1,144 @@
+/**
+ * Paste actions (p, P)
+ */
+
+import { calculateOffsetFromPosition } from "@/utils/editor-position";
+import type { Action, EditorContext } from "../core/types";
+import { getVimClipboard } from "../operators/yank-operator";
+
+/**
+ * Paste after cursor (p)
+ */
+export const pasteAction: Action = {
+  name: "paste",
+  repeatable: true,
+  entersInsertMode: false,
+
+  execute: (context: EditorContext): void => {
+    const clipboard = getVimClipboard();
+    if (!clipboard.content) return;
+
+    const { content, lines, updateContent, setCursorPosition, cursor } = context;
+
+    if (clipboard.linewise) {
+      // Paste as new line below current line
+      const newLines = [...lines];
+      const pastedLines = clipboard.content.replace(/\n$/, "").split("\n");
+
+      // Insert after current line
+      newLines.splice(cursor.line + 1, 0, ...pastedLines);
+      const newContent = newLines.join("\n");
+
+      // Move cursor to beginning of first pasted line
+      const newLine = cursor.line + 1;
+      const newOffset = calculateOffsetFromPosition(newLine, 0, newLines);
+
+      updateContent(newContent);
+      setCursorPosition({
+        line: newLine,
+        column: 0,
+        offset: newOffset,
+      });
+    } else {
+      // Character-wise paste after cursor
+      let pasteOffset = cursor.offset;
+
+      // If not at end of line, move one character right
+      if (cursor.offset < content.length && content[cursor.offset] !== "\n") {
+        pasteOffset = cursor.offset + 1;
+      }
+
+      const newContent =
+        content.slice(0, pasteOffset) + clipboard.content + content.slice(pasteOffset);
+
+      updateContent(newContent);
+
+      // Move cursor to end of pasted content - 1 (vim behavior)
+      const newOffset = pasteOffset + clipboard.content.length - 1;
+      const newLines = newContent.split("\n");
+      let line = 0;
+      let offset = 0;
+
+      // Find the line containing the new cursor offset
+      for (let i = 0; i < newLines.length; i++) {
+        if (offset + newLines[i].length >= newOffset) {
+          line = i;
+          break;
+        }
+        offset += newLines[i].length + 1; // +1 for newline
+      }
+
+      const column = newOffset - offset;
+      setCursorPosition({
+        line,
+        column: Math.max(0, column),
+        offset: Math.max(0, newOffset),
+      });
+    }
+  },
+};
+
+/**
+ * Paste before cursor (P)
+ */
+export const pasteBeforeAction: Action = {
+  name: "paste-before",
+  repeatable: true,
+  entersInsertMode: false,
+
+  execute: (context: EditorContext): void => {
+    const clipboard = getVimClipboard();
+    if (!clipboard.content) return;
+
+    const { content, lines, updateContent, setCursorPosition, cursor } = context;
+
+    if (clipboard.linewise) {
+      // Paste as new line above current line
+      const newLines = [...lines];
+      const pastedLines = clipboard.content.replace(/\n$/, "").split("\n");
+
+      // Insert before current line
+      newLines.splice(cursor.line, 0, ...pastedLines);
+      const newContent = newLines.join("\n");
+
+      // Move cursor to beginning of first pasted line
+      const newLine = cursor.line;
+      const newOffset = calculateOffsetFromPosition(newLine, 0, newLines);
+
+      updateContent(newContent);
+      setCursorPosition({
+        line: newLine,
+        column: 0,
+        offset: newOffset,
+      });
+    } else {
+      // Character-wise paste at cursor
+      const newContent =
+        content.slice(0, cursor.offset) + clipboard.content + content.slice(cursor.offset);
+
+      updateContent(newContent);
+
+      // Move cursor to end of pasted content - 1 (vim behavior)
+      const newOffset = cursor.offset + clipboard.content.length - 1;
+      const newLines = newContent.split("\n");
+      let line = 0;
+      let offset = 0;
+
+      // Find the line containing the new cursor offset
+      for (let i = 0; i < newLines.length; i++) {
+        if (offset + newLines[i].length >= newOffset) {
+          line = i;
+          break;
+        }
+        offset += newLines[i].length + 1; // +1 for newline
+      }
+
+      const column = newOffset - offset;
+      setCursorPosition({
+        line,
+        column: Math.max(0, column),
+        offset: Math.max(0, newOffset),
+      });
+    }
+  },
+};

src/stores/vim/actions/paste-actions.ts

@@ -0,0 +1,31 @@
+/**
+ * Repeat action (.)
+ */
+
+import { useVimStore } from "../../vim-store";
+import { executeVimCommand } from "../core/command-executor";
+import type { Action } from "../core/types";
+
+/**
+ * Repeat action - repeats the last operation
+ */
+export const repeatAction: Action = {
+  name: "repeat",
+  repeatable: false, // The dot command itself is not repeatable
+
+  execute: (): void => {
+    const lastOperation = useVimStore.getState().lastOperation;
+
+    if (!lastOperation || !lastOperation.keys || lastOperation.keys.length === 0) {
+      // Nothing to repeat
+      return;
+    }
+
+    // Execute the last command
+    const success = executeVimCommand(lastOperation.keys);
+
+    if (!success) {
+      console.warn("Failed to repeat last operation:", lastOperation.keys);
+    }
+  },
+};