@vemjs/core 0.1.0

package/src/index.ts

@@ -0,0 +1,32 @@
+/**
+ * @vemjs/core - Pure Vim State Machine Engine
+ */
+
+export type EditorMode = 'NORMAL' | 'INSERT' | 'VISUAL' | 'COMMAND';
+
+export interface Position {
+  line: number;
+  character: number;
+}
+
+export { VimBuffer, UndoManager } from './buffer';
+export {
+  getCharClass,
+  nextPosition,
+  prevPosition,
+  getWordForward,
+  getWordBackward,
+  getWordEndForward,
+  getTextObjectRange,
+} from './motions';
+export { parseKeys } from './parser';
+export type { ParsedCommand } from './parser';
+export { VemEditorState } from './editor';
+export type {
+  RegisterContent,
+  VisualType,
+  VisualSelection,
+  Diagnostic,
+  DiagnosticSeverity,
+} from './editor';
+export { ConfigLoader, type VemConfig } from './ConfigLoader';

package/src/motions.ts

@@ -0,0 +1,216 @@
+import type { Position } from './index';
+import { VimBuffer } from './buffer';
+
+export function getCharClass(char: string): number {
+  if (!char) return 0; // EOF/EOL
+  if (/\s/.test(char)) return 1; // Whitespace
+  if (/^[a-zA-Z0-9_]$/.test(char)) return 2; // Word char
+  return 3; // Punctuation/Special
+}
+
+export function nextPosition(buffer: VimBuffer, pos: Position): Position | null {
+  const line = buffer.getLine(pos.line);
+  if (pos.character < line.length - 1) {
+    return { line: pos.line, character: pos.character + 1 };
+  }
+  if (pos.line < buffer.getLineCount() - 1) {
+    return { line: pos.line + 1, character: 0 };
+  }
+  return null;
+}
+
+export function prevPosition(buffer: VimBuffer, pos: Position): Position | null {
+  if (pos.character > 0) {
+    return { line: pos.line, character: pos.character - 1 };
+  }
+  if (pos.line > 0) {
+    const prevLine = buffer.getLine(pos.line - 1);
+    return { line: pos.line - 1, character: Math.max(0, prevLine.length - 1) };
+  }
+  return null;
+}
+
+export function getWordForward(buffer: VimBuffer, start: Position): Position {
+  let curr: Position | null = start;
+  const startChar = buffer.getLine(start.line)[start.character];
+  if (!startChar) {
+    const next = nextPosition(buffer, start);
+    if (!next) return start;
+    return next;
+  }
+
+  let startClass = getCharClass(startChar);
+
+  // 1. Move past characters of the same class (unless starting on whitespace)
+  if (startClass !== 1) {
+    while (curr) {
+      const next = nextPosition(buffer, curr);
+      if (!next) return curr;
+      const nextChar = buffer.getLine(next.line)[next.character];
+      const nextClass = getCharClass(nextChar);
+      if (nextClass !== startClass) {
+        curr = next;
+        break;
+      }
+      curr = next;
+    }
+  }
+
+  // 2. We are now at a different class. If it's whitespace, skip it
+  if (curr) {
+    let currChar = buffer.getLine(curr.line)[curr.character];
+    let currClass = getCharClass(currChar);
+    if (currClass === 1) {
+      while (curr) {
+        const next = nextPosition(buffer, curr);
+        if (!next) return curr;
+        const nextChar = buffer.getLine(next.line)[next.character];
+        const nextClass = getCharClass(nextChar);
+        if (nextClass !== 1) {
+          curr = next;
+          break;
+        }
+        curr = next;
+      }
+    }
+  }
+
+  return curr || start;
+}
+
+export function getWordBackward(buffer: VimBuffer, start: Position): Position {
+  let curr: Position | null = prevPosition(buffer, start);
+  if (!curr) return start;
+
+  let currChar = buffer.getLine(curr.line)[curr.character];
+  let currClass = getCharClass(currChar);
+
+  // If starting on whitespace, skip all preceding whitespace
+  if (currClass === 1) {
+    while (curr) {
+      const prev = prevPosition(buffer, curr);
+      if (!prev) return curr;
+      const prevChar = buffer.getLine(prev.line)[prev.character];
+      const prevClass = getCharClass(prevChar);
+      if (prevClass !== 1) {
+        currClass = prevClass;
+        curr = prev;
+        break;
+      }
+      curr = prev;
+    }
+  }
+
+  // Now scan backward through the same class
+  while (curr) {
+    const prev = prevPosition(buffer, curr);
+    if (!prev) return curr;
+    const prevChar = buffer.getLine(prev.line)[prev.character];
+    const prevClass = getCharClass(prevChar);
+    if (prevClass !== currClass) {
+      return curr;
+    }
+    curr = prev;
+  }
+
+  return start;
+}
+
+export function getWordEndForward(buffer: VimBuffer, start: Position): Position {
+  let curr: Position | null = nextPosition(buffer, start);
+  if (!curr) return start;
+
+  let currChar = buffer.getLine(curr.line)[curr.character];
+  let currClass = getCharClass(currChar);
+
+  // Skip whitespace
+  if (currClass === 1) {
+    while (curr) {
+      const next = nextPosition(buffer, curr);
+      if (!next) return curr;
+      const nextChar = buffer.getLine(next.line)[next.character];
+      const nextClass = getCharClass(nextChar);
+      if (nextClass !== 1) {
+        currClass = nextClass;
+        curr = next;
+        break;
+      }
+      curr = next;
+    }
+  }
+
+  // Scan until the character class changes, but stop on the last character of that class
+  while (curr) {
+    const next = nextPosition(buffer, curr);
+    if (!next) return curr;
+    const nextChar = buffer.getLine(next.line)[next.character];
+    const nextClass = getCharClass(nextChar);
+    if (nextClass !== currClass) {
+      return curr;
+    }
+    curr = next;
+  }
+
+  return start;
+}
+
+export function getTextObjectRange(
+  buffer: VimBuffer,
+  pos: Position,
+  textObj: string,
+): { start: Position; end: Position } | null {
+  const line = buffer.getLine(pos.line);
+  if (line.length === 0) {
+    return { start: { ...pos }, end: { ...pos } };
+  }
+
+  const char = line[pos.character] || '';
+  const initialClass = getCharClass(char);
+
+  // Find start of current block
+  let startCharIdx = pos.character;
+  while (startCharIdx > 0) {
+    if (getCharClass(line[startCharIdx - 1]) !== initialClass) {
+      break;
+    }
+    startCharIdx--;
+  }
+
+  // Find end of current block
+  let endCharIdx = pos.character;
+  while (endCharIdx < line.length - 1) {
+    if (getCharClass(line[endCharIdx + 1]) !== initialClass) {
+      break;
+    }
+    endCharIdx++;
+  }
+
+  const start: Position = { line: pos.line, character: startCharIdx };
+  const end: Position = { line: pos.line, character: endCharIdx };
+
+  if (textObj === 'aw') {
+    // Extend to include trailing whitespace (on the same line)
+    let nextIdx = end.character + 1;
+    let extendedTrailing = false;
+    while (nextIdx < line.length && /\s/.test(line[nextIdx])) {
+      extendedTrailing = true;
+      nextIdx++;
+    }
+    if (extendedTrailing) {
+      end.character = nextIdx - 1;
+    } else {
+      // If no trailing whitespace, extend to include leading whitespace
+      let prevIdx = start.character - 1;
+      let extendedLeading = false;
+      while (prevIdx >= 0 && /\s/.test(line[prevIdx])) {
+        extendedLeading = true;
+        prevIdx--;
+      }
+      if (extendedLeading) {
+        start.character = prevIdx + 1;
+      }
+    }
+  }
+
+  return { start, end };
+}

package/src/parser.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'bun:test';
+import { parseKeys } from './parser';
+
+describe('Vim Keybinding Parser', () => {
+  it('should parse single motions', () => {
+    expect(parseKeys(['w'])).toEqual({
+      count: 1,
+      motion: 'w',
+      isComplete: true,
+      isValid: true,
+    });
+
+    expect(parseKeys(['g', 'g'])).toEqual({
+      count: 1,
+      motion: 'gg',
+      isComplete: true,
+      isValid: true,
+    });
+  });
+
+  it('should handle counts with motions', () => {
+    expect(parseKeys(['3', 'w'])).toEqual({
+      count: 3,
+      motion: 'w',
+      isComplete: true,
+      isValid: true,
+    });
+
+    expect(parseKeys(['1', '0', 'j'])).toEqual({
+      count: 10,
+      motion: 'j',
+      isComplete: true,
+      isValid: true,
+    });
+  });
+
+  it('should handle counts with operators and motions', () => {
+    expect(parseKeys(['d', '3', 'w'])).toEqual({
+      count: 3,
+      operator: 'd',
+      motion: 'w',
+      isComplete: true,
+      isValid: true,
+    });
+
+    expect(parseKeys(['2', 'c', '3', 'b'])).toEqual({
+      count: 6,
+      operator: 'c',
+      motion: 'b',
+      isComplete: true,
+      isValid: true,
+    });
+  });
+
+  it('should handle double operators', () => {
+    expect(parseKeys(['d', 'd'])).toEqual({
+      count: 1,
+      operator: 'd',
+      command: 'dd',
+      isComplete: true,
+      isValid: true,
+    });
+
+    expect(parseKeys(['3', 'y', 'y'])).toEqual({
+      count: 3,
+      operator: 'y',
+      command: 'yy',
+      isComplete: true,
+      isValid: true,
+    });
+  });
+
+  it('should handle text objects after operators', () => {
+    expect(parseKeys(['d', 'i', 'w'])).toEqual({
+      count: 1,
+      operator: 'd',
+      textObject: 'iw',
+      isComplete: true,
+      isValid: true,
+    });
+
+    expect(parseKeys(['2', 'c', 'a', 'w'])).toEqual({
+      count: 2,
+      operator: 'c',
+      textObject: 'aw',
+      isComplete: true,
+      isValid: true,
+    });
+  });
+
+  it('should return incomplete states for partial keys', () => {
+    expect(parseKeys(['g'])).toEqual({
+      count: 1,
+      isComplete: false,
+      isValid: true,
+    });
+
+    expect(parseKeys(['d', 'i'])).toEqual({
+      count: 1,
+      operator: 'd',
+      isComplete: false,
+      isValid: true,
+    });
+
+    expect(parseKeys(['3', 'c'])).toEqual({
+      count: 3,
+      operator: 'c',
+      isComplete: false,
+      isValid: true,
+    });
+  });
+
+  it('should return invalid for incorrect sequences', () => {
+    expect(parseKeys(['d', 'x'])).toEqual({
+      count: 1,
+      operator: 'd',
+      isComplete: true,
+      isValid: false,
+    });
+  });
+});

package/src/parser.ts

@@ -0,0 +1,219 @@
+import type { EditorMode } from './index';
+
+export interface ParsedCommand {
+  count: number;
+  operator?: 'd' | 'c' | 'y';
+  motion?: string;
+  textObject?: string;
+  command?: string;
+  isComplete: boolean;
+  isValid: boolean;
+}
+
+export function parseKeys(keys: string[], mode: EditorMode = 'NORMAL'): ParsedCommand {
+  const result: ParsedCommand = {
+    count: 1,
+    isComplete: false,
+    isValid: true,
+  };
+
+  if (keys.length === 0) {
+    return result;
+  }
+
+  let idx = 0;
+
+  // 1. Parse first count
+  let count1Str = '';
+  while (idx < keys.length && /^\d$/.test(keys[idx])) {
+    if (keys[idx] === '0' && count1Str === '') {
+      break;
+    }
+    count1Str += keys[idx];
+    idx++;
+  }
+  const count1 = count1Str ? parseInt(count1Str, 10) : 1;
+
+  if (idx >= keys.length) {
+    result.count = count1;
+    result.isComplete = false;
+    result.isValid = true;
+    return result;
+  }
+
+  const remaining = keys.slice(idx);
+  const remStr = remaining.join('');
+
+  if (mode === 'VISUAL') {
+    // In Visual mode, d, c, y, x are immediate commands
+    const visualCommands = ['d', 'c', 'y', 'x', 'Escape', 'v', 'V', '<C-v>'];
+    if (visualCommands.includes(remStr)) {
+      result.count = count1;
+      result.command = remStr;
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    // Motions in Visual mode
+    if (remStr === 'g') {
+      result.isComplete = false;
+      result.isValid = true;
+      return result;
+    }
+    if (remStr === 'gg') {
+      result.count = count1;
+      result.motion = 'gg';
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    const singleKeyMotions = ['h', 'j', 'k', 'l', 'w', 'b', 'e', '0', '$', 'G'];
+    if (singleKeyMotions.includes(remStr)) {
+      result.count = count1;
+      result.motion = remStr;
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    result.isValid = false;
+    result.isComplete = true;
+    return result;
+  }
+
+  // NORMAL mode parsing
+  // 2. Parse operator (d, c, y)
+  let op: 'd' | 'c' | 'y' | undefined;
+  const firstNonDigit = keys[idx];
+  if (firstNonDigit === 'd' || firstNonDigit === 'c' || firstNonDigit === 'y') {
+    op = firstNonDigit;
+    idx++;
+  }
+
+  if (op) {
+    // We have an operator
+    // 3. Parse optional second count
+    let count2Str = '';
+    while (idx < keys.length && /^\d$/.test(keys[idx])) {
+      if (keys[idx] === '0' && count2Str === '') {
+        break;
+      }
+      count2Str += keys[idx];
+      idx++;
+    }
+    const count2 = count2Str ? parseInt(count2Str, 10) : 1;
+    result.count = count1 * count2;
+    result.operator = op;
+
+    if (idx >= keys.length) {
+      result.isComplete = false;
+      result.isValid = true;
+      return result;
+    }
+
+    const remainingOp = keys.slice(idx);
+    const remOpStr = remainingOp.join('');
+
+    // Double operator check (dd, cc, yy)
+    if (remOpStr === op) {
+      result.command = op + op; // e.g. "dd"
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    // Text objects: iw, aw
+    if (remOpStr === 'i' || remOpStr === 'a') {
+      result.isComplete = false;
+      result.isValid = true;
+      return result;
+    }
+    if (remOpStr === 'iw' || remOpStr === 'aw') {
+      result.textObject = remOpStr;
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    // Motions: h, j, k, l, w, b, e, 0, $, G, gg
+    if (remOpStr === 'g') {
+      result.isComplete = false;
+      result.isValid = true;
+      return result;
+    }
+    if (remOpStr === 'gg') {
+      result.motion = 'gg';
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    const singleKeyMotions = ['h', 'j', 'k', 'l', 'w', 'b', 'e', '0', '$', 'G'];
+    if (singleKeyMotions.includes(remOpStr)) {
+      result.motion = remOpStr;
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    result.isValid = false;
+    result.isComplete = true;
+    return result;
+  } else {
+    // No operator
+    result.count = count1;
+    const remainingNormal = keys.slice(idx);
+    const remNormalStr = remainingNormal.join('');
+
+    if (remNormalStr === 'g') {
+      result.isComplete = false;
+      result.isValid = true;
+      return result;
+    }
+    if (remNormalStr === 'gg') {
+      result.motion = 'gg';
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    const singleKeyMotions = ['h', 'j', 'k', 'l', 'w', 'b', 'e', '0', '$', 'G'];
+    if (singleKeyMotions.includes(remNormalStr)) {
+      result.motion = remNormalStr;
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    const commands = [
+      'i',
+      'I',
+      'a',
+      'A',
+      'o',
+      'O',
+      'v',
+      'V',
+      '<C-v>',
+      'u',
+      '<C-r>',
+      'x',
+      'p',
+      'P',
+      ':',
+      'Escape',
+    ];
+    if (commands.includes(remNormalStr)) {
+      result.command = remNormalStr;
+      result.isComplete = true;
+      result.isValid = true;
+      return result;
+    }
+
+    result.isValid = false;
+    result.isComplete = true;
+    return result;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts"]
+}