pi-vim 0.1.3 → 0.1.7

package/motions.ts

@@ -5,18 +5,105 @@
 import type { CharMotion } from "./types.js";
 
 // Character types for word boundary detection
+export type WordMotionClass = "word" | "WORD";
+
 enum CharType {
   Space = 0,
-  Keyword = 1, // alphanumeric + underscore
+  Keyword = 1, // alphanumeric + underscore (or all non-space in WORD mode)
   Other = 2, // punctuation/symbols
 }
 
-function getCharType(c: string | undefined): CharType {
+function getCharType(
+  c: string | undefined,
+  semanticClass: WordMotionClass = "word",
+): CharType {
   if (!c || /\s/.test(c)) return CharType.Space;
+  if (semanticClass === "WORD") return CharType.Keyword;
   if (/\w/.test(c)) return CharType.Keyword;
   return CharType.Other;
 }
 
+function clampLineIndex(lines: readonly string[], lineIndex: number): number {
+  if (lines.length === 0) return 0;
+  if (!Number.isFinite(lineIndex)) return 0;
+  const normalized = Math.trunc(lineIndex);
+  return Math.max(0, Math.min(normalized, lines.length - 1));
+}
+
+/**
+ * True when line matches ^\s*$.
+ */
+export function isBlankLine(line: string | undefined): boolean {
+  if (line === undefined) return true;
+  return /^\s*$/.test(line);
+}
+
+/**
+ * Paragraph start: non-blank line at BOF or after a blank line.
+ */
+export function isParagraphStart(lines: readonly string[], lineIndex: number): boolean {
+  if (!Number.isInteger(lineIndex)) return false;
+  if (lineIndex < 0 || lineIndex >= lines.length) return false;
+  if (isBlankLine(lines[lineIndex])) return false;
+  if (lineIndex === 0) return true;
+  return isBlankLine(lines[lineIndex - 1]);
+}
+
+/**
+ * One step of } motion from current line index.
+ */
+export function findNextParagraphStart(lines: readonly string[], fromLine: number): number {
+  if (lines.length === 0) return 0;
+
+  const start = clampLineIndex(lines, fromLine) + 1;
+  for (let i = start; i < lines.length; i++) {
+    if (isParagraphStart(lines, i)) return i;
+  }
+
+  return lines.length - 1;
+}
+
+/**
+ * One step of { motion from current line index.
+ */
+export function findPrevParagraphStart(lines: readonly string[], fromLine: number): number {
+  if (lines.length === 0) return 0;
+
+  const start = clampLineIndex(lines, fromLine) - 1;
+  for (let i = start; i >= 0; i--) {
+    if (isParagraphStart(lines, i)) return i;
+  }
+
+  return 0;
+}
+
+/**
+ * Paragraph motion target for counted { / } semantics.
+ */
+export function findParagraphMotionTarget(
+  lines: readonly string[],
+  fromLine: number,
+  direction: "forward" | "backward",
+  count: number = 1,
+): number {
+  if (lines.length === 0) return 0;
+
+  const steps = Number.isFinite(count) && count > 0 ? Math.floor(count) : 1;
+  let currentLine = clampLineIndex(lines, fromLine);
+
+  for (let i = 0; i < steps; i++) {
+    const nextLine =
+      direction === "forward"
+        ? findNextParagraphStart(lines, currentLine)
+        : findPrevParagraphStart(lines, currentLine);
+
+    if (nextLine === currentLine) break;
+    currentLine = nextLine;
+  }
+
+  return currentLine;
+}
+
 /**
  * Reverse a character motion direction (f ↔ F, t ↔ T).
  */
@@ -40,26 +127,35 @@ export function findCharMotionTarget(
   motion: CharMotion,
   targetChar: string,
   isRepeat: boolean = false,
+  count: number = 1,
 ): number | null {
   const isForward = motion === "f" || motion === "t";
   const isTill = motion === "t" || motion === "T";
-
-  // For till repeats (;/,), we need extra offset to skip past the character we stopped before/after
-  const tillRepeatOffset = isTill && isRepeat ? 1 : 0;
-
-  if (isForward) {
-    const searchStart = col + 1 + tillRepeatOffset;
-    const idx = line.indexOf(targetChar, searchStart);
-    if (idx !== -1) {
-      return isTill ? idx - 1 : idx;
+  const steps = Number.isFinite(count) && count > 0 ? Math.floor(count) : 1;
+
+  let currentPos = col;
+
+  for (let i = 0; i < steps; i++) {
+    const isFirst = i === 0;
+    const isFinal = i === steps - 1;
+    const tillRepeatOffset = isFirst && isTill && isRepeat ? 1 : 0;
+
+    if (isForward) {
+      const searchStart = currentPos + 1 + tillRepeatOffset;
+      const idx = line.indexOf(targetChar, searchStart);
+      if (idx === -1) return null;
+      if (isFinal) return isTill ? idx - 1 : idx;
+      currentPos = idx;
+      continue;
     }
-  } else {
-    const searchStart = col - 1 - tillRepeatOffset;
+
+    const searchStart = currentPos - 1 - tillRepeatOffset;
     const idx = line.lastIndexOf(targetChar, searchStart);
-    if (idx !== -1) {
-      return isTill ? idx + 1 : idx;
-    }
+    if (idx === -1) return null;
+    if (isFinal) return isTill ? idx + 1 : idx;
+    currentPos = idx;
   }
+
   return null;
 }
 
@@ -71,6 +167,7 @@ export function findWordMotionTarget(
   col: number,
   direction: "forward" | "backward",
   target: "start" | "end",
+  semanticClass: WordMotionClass = "word",
 ): number {
   const len = line.length;
   if (len === 0) return 0;
@@ -82,15 +179,15 @@ export function findWordMotionTarget(
 
     if (target === "start") {
       // w: move to start of next word
-      const startType = getCharType(line[i]);
+      const startType = getCharType(line[i], semanticClass);
 
       // Skip current word/punct block
       if (startType !== CharType.Space) {
-        while (i < len && getCharType(line[i]) === startType) i++;
+        while (i < len && getCharType(line[i], semanticClass) === startType) i++;
       }
 
       // Skip whitespace
-      while (i < len && getCharType(line[i]) === CharType.Space) i++;
+      while (i < len && getCharType(line[i], semanticClass) === CharType.Space) i++;
 
       return i;
     }
@@ -99,13 +196,13 @@ export function findWordMotionTarget(
     if (i < len - 1) i++;
 
     // Skip whitespace forward
-    while (i < len && getCharType(line[i]) === CharType.Space) i++;
+    while (i < len && getCharType(line[i], semanticClass) === CharType.Space) i++;
 
     // Now at start of next word (or end of line). Find end.
     if (i >= len) return len;
 
-    const type = getCharType(line[i]);
-    while (i < len - 1 && getCharType(line[i + 1]) === type) i++;
+    const type = getCharType(line[i], semanticClass);
+    while (i < len - 1 && getCharType(line[i + 1], semanticClass) === type) i++;
 
     return i;
   }
@@ -115,11 +212,11 @@ export function findWordMotionTarget(
   if (i > 0) i--;
 
   // Skip whitespace backward
-  while (i > 0 && getCharType(line[i]) === CharType.Space) i--;
+  while (i > 0 && getCharType(line[i], semanticClass) === CharType.Space) i--;
 
   // Now at end of prev word (or start of line). Find start.
-  const type = getCharType(line[i]);
-  while (i > 0 && getCharType(line[i - 1]) === type) i--;
+  const type = getCharType(line[i], semanticClass);
+  while (i > 0 && getCharType(line[i - 1], semanticClass) === type) i--;
 
   return i;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vim",
-  "version": "0.1.3",
+  "version": "0.1.7",
   "description": "Vim-style modal editing for Pi's TUI editor",
   "type": "module",
   "keywords": [
@@ -23,7 +23,9 @@
   "scripts": {
     "build": "echo 'nothing to build'",
     "test": "node --import tsx/esm --test 'test/**/*.test.ts'",
-    "check": "npm run test"
+    "check": "npm run test",
+    "pack:check": "node --import tsx/esm script/pack-check.ts",
+    "prepublishOnly": "npm run pack:check && npm test"
   },
   "pi": {
     "extensions": [

package/word-boundary-cache.ts

@@ -1,9 +1,11 @@
 /**
  * Line-local cache for Vim word motion boundaries.
  *
- * Keyed by exact line content to avoid stale boundary reuse.
+ * Keyed by semantic class + exact line content to avoid stale boundary reuse.
  */
 
+import type { WordMotionClass } from "./motions.js";
+
 export type WordMotionDirection = "forward" | "backward";
 export type WordMotionTarget = "start" | "end";
 
@@ -22,13 +24,20 @@ export interface WordBoundaryData {
   readonly prevNonSpaceAtOrBefore: Int32Array;
 }
 
-function getCharType(ch: string | undefined): CharType {
+function getCharType(
+  ch: string | undefined,
+  semanticClass: WordMotionClass = "word",
+): CharType {
   if (!ch || /\s/.test(ch)) return CharType.Space;
+  if (semanticClass === "WORD") return CharType.Word;
   if (/\w/.test(ch)) return CharType.Word;
   return CharType.Other;
 }
 
-function buildWordBoundaryData(line: string): WordBoundaryData {
+function buildWordBoundaryData(
+  line: string,
+  semanticClass: WordMotionClass = "word",
+): WordBoundaryData {
   const len = line.length;
   const charTypes = new Uint8Array(len);
   const runStartByIndex = new Int32Array(len);
@@ -40,7 +49,7 @@ function buildWordBoundaryData(line: string): WordBoundaryData {
   prevNonSpaceAtOrBefore.fill(-1);
 
   for (let i = 0; i < len; i++) {
-    charTypes[i] = getCharType(line[i]);
+    charTypes[i] = getCharType(line[i], semanticClass);
   }
 
   for (let runStart = 0; runStart < len;) {
@@ -149,11 +158,16 @@ export class WordBoundaryCache {
       : DEFAULT_MAX_CACHE_ENTRIES;
   }
 
-  get(line: string): WordBoundaryData {
-    const cached = this.entries.get(line);
+  private makeCacheKey(line: string, semanticClass: WordMotionClass): string {
+    return `${semanticClass}\u0000${line}`;
+  }
+
+  get(line: string, semanticClass: WordMotionClass = "word"): WordBoundaryData {
+    const key = this.makeCacheKey(line, semanticClass);
+    const cached = this.entries.get(key);
     if (cached) return cached;
 
-    const built = buildWordBoundaryData(line);
+    const built = buildWordBoundaryData(line, semanticClass);
 
     if (this.entries.size >= this.maxEntries) {
       const oldestKey = this.entries.keys().next().value;
@@ -162,7 +176,7 @@ export class WordBoundaryCache {
       }
     }
 
-    this.entries.set(line, built);
+    this.entries.set(key, built);
     return built;
   }
 
@@ -171,10 +185,11 @@ export class WordBoundaryCache {
     col: number,
     direction: WordMotionDirection,
     target: WordMotionTarget,
+    semanticClass: WordMotionClass = "word",
   ): number | null {
     if (!Number.isInteger(col) || col < 0) return null;
 
-    const boundaries = this.get(line);
+    const boundaries = this.get(line, semanticClass);
     return findTargetInLine(boundaries, col, direction, target);
   }
 }