@vemjs/core 0.1.0

package/src/buffer.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'bun:test';
+import { VimBuffer, UndoManager } from './buffer';
+
+describe('VimBuffer', () => {
+  it('should initialize with empty line or given text', () => {
+    const buf1 = new VimBuffer();
+    expect(buf1.getLines()).toEqual(['']);
+
+    const buf2 = new VimBuffer('hello\nworld');
+    expect(buf2.getLines()).toEqual(['hello', 'world']);
+  });
+
+  it('should support line insertion, set, and delete', () => {
+    const buf = new VimBuffer('line1\nline2');
+    buf.insertLine(1, 'inserted');
+    expect(buf.getLines()).toEqual(['line1', 'inserted', 'line2']);
+
+    buf.setLine(2, 'modified');
+    expect(buf.getLines()).toEqual(['line1', 'inserted', 'modified']);
+
+    const deleted = buf.deleteLines(1, 1);
+    expect(deleted).toEqual(['inserted']);
+    expect(buf.getLines()).toEqual(['line1', 'modified']);
+  });
+
+  it('should support text insertion at a position', () => {
+    const buf = new VimBuffer('hello world');
+    const endPos = buf.insertText({ line: 0, character: 6 }, 'beautiful ');
+    expect(buf.getText()).toBe('hello beautiful world');
+    expect(endPos).toEqual({ line: 0, character: 16 });
+
+    const buf2 = new VimBuffer('line1\nline2');
+    const endPos2 = buf2.insertText({ line: 0, character: 5 }, '\nmiddle\nline');
+    expect(buf2.getText()).toBe('line1\nmiddle\nline\nline2');
+    expect(endPos2).toEqual({ line: 2, character: 4 });
+  });
+
+  it('should support deleting ranges of text', () => {
+    const buf = new VimBuffer('hello beautiful world');
+    buf.deleteRange({ line: 0, character: 5 }, { line: 0, character: 15 });
+    expect(buf.getText()).toBe('hello world');
+
+    const buf2 = new VimBuffer('line1\nmiddle\nline\nline2');
+    // Delete from middle of line1 to middle of line
+    buf2.deleteRange({ line: 0, character: 4 }, { line: 2, character: 4 });
+    expect(buf2.getText()).toBe('line\nline2');
+  });
+});
+
+describe('UndoManager', () => {
+  it('should handle push, undo, and redo correctly', () => {
+    const history = new UndoManager();
+    let current = ['hello'];
+
+    history.push(current);
+    current = ['hello', 'world'];
+
+    const undone = history.undo(current);
+    expect(undone).toEqual(['hello']);
+
+    const redone = history.redo(undone!);
+    expect(redone).toEqual(['hello', 'world']);
+  });
+});

package/src/buffer.ts

@@ -0,0 +1,151 @@
+import type { Position } from './index';
+
+export class VimBuffer {
+  private lines: string[] = [''];
+  private changeCallbacks: (() => void)[] = [];
+
+  constructor(initialText?: string) {
+    if (initialText !== undefined) {
+      this.lines = initialText.split(/\r?\n/);
+      if (this.lines.length === 0) {
+        this.lines = [''];
+      }
+    }
+  }
+
+  public onChange(callback: () => void): void {
+    this.changeCallbacks.push(callback);
+  }
+
+  private triggerChange(): void {
+    for (const cb of this.changeCallbacks) {
+      cb();
+    }
+  }
+
+  public getLines(): string[] {
+    return [...this.lines];
+  }
+
+  public setLines(lines: string[]): void {
+    this.lines = [...lines];
+    if (this.lines.length === 0) {
+      this.lines = [''];
+    }
+    this.triggerChange();
+  }
+
+  public getLine(lineIdx: number): string {
+    if (lineIdx < 0 || lineIdx >= this.lines.length) {
+      return '';
+    }
+    return this.lines[lineIdx];
+  }
+
+  public getLineCount(): number {
+    return this.lines.length;
+  }
+
+  public insertText(pos: Position, text: string): Position {
+    const line = this.getLine(pos.line);
+    const before = line.substring(0, pos.character);
+    const after = line.substring(pos.character);
+    const insertedLines = text.split(/\r?\n/);
+
+    if (insertedLines.length === 1) {
+      this.lines[pos.line] = before + insertedLines[0] + after;
+      this.triggerChange();
+      return {
+        line: pos.line,
+        character: pos.character + insertedLines[0].length,
+      };
+    } else {
+      this.lines[pos.line] = before + insertedLines[0];
+      const middleLines = insertedLines.slice(1, insertedLines.length - 1);
+      const lastLine = insertedLines[insertedLines.length - 1] + after;
+
+      this.lines.splice(pos.line + 1, 0, ...middleLines, lastLine);
+      this.triggerChange();
+      return {
+        line: pos.line + insertedLines.length - 1,
+        character: insertedLines[insertedLines.length - 1].length,
+      };
+    }
+  }
+
+  public deleteRange(start: Position, end: Position): void {
+    let s = { ...start };
+    let e = { ...end };
+
+    // Ensure start is before end
+    if (s.line > e.line || (s.line === e.line && s.character > e.character)) {
+      const temp = s;
+      s = e;
+      e = temp;
+    }
+
+    const startLine = this.getLine(s.line);
+    const endLine = this.getLine(e.line);
+
+    const before = startLine.substring(0, s.character);
+    const after = endLine.substring(e.character);
+
+    this.lines[s.line] = before + after;
+    if (e.line > s.line) {
+      this.lines.splice(s.line + 1, e.line - s.line);
+    }
+    if (this.lines.length === 0) {
+      this.lines = [''];
+    }
+    this.triggerChange();
+  }
+
+  public deleteLines(startLineIdx: number, endLineIdx: number): string[] {
+    const min = Math.max(0, Math.min(startLineIdx, endLineIdx));
+    const max = Math.min(this.lines.length - 1, Math.max(startLineIdx, endLineIdx));
+    const deleted = this.lines.splice(min, max - min + 1);
+    if (this.lines.length === 0) {
+      this.lines = [''];
+    }
+    this.triggerChange();
+    return deleted;
+  }
+
+  public insertLine(lineIdx: number, text: string): void {
+    this.lines.splice(lineIdx, 0, text);
+    this.triggerChange();
+  }
+
+  public setLine(lineIdx: number, text: string): void {
+    if (lineIdx >= 0 && lineIdx < this.lines.length) {
+      this.lines[lineIdx] = text;
+      this.triggerChange();
+    }
+  }
+
+  public getText(): string {
+    return this.lines.join('\n');
+  }
+}
+
+export class UndoManager {
+  private undoStack: string[][] = [];
+  private redoStack: string[][] = [];
+
+  public push(lines: string[]): void {
+    this.undoStack.push([...lines]);
+    this.redoStack = [];
+  }
+
+  public undo(currentLines: string[]): string[] | null {
+    if (this.undoStack.length === 0) return null;
+    this.redoStack.push([...currentLines]);
+    return this.undoStack.pop() || null;
+  }
+
+  public redo(currentLines: string[]): string[] | null {
+    if (this.redoStack.length === 0) return null;
+    this.undoStack.push([...currentLines]);
+    return this.redoStack.pop() || null;
+  }
+}

package/src/editor.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, it } from 'bun:test';
+import { VemEditorState } from './editor';
+
+describe('VemEditorState', () => {
+  it('should start in NORMAL mode with default cursor', () => {
+    const editor = new VemEditorState('line1\nline2');
+    expect(editor.getMode()).toBe('NORMAL');
+    expect(editor.getCursor()).toEqual({ line: 0, character: 0 });
+    expect(editor.getBuffer().getText()).toBe('line1\nline2');
+  });
+
+  it('should transition to INSERT mode and accept character insertions', () => {
+    const editor = new VemEditorState('hello');
+    editor.handleKey('i');
+    expect(editor.getMode()).toBe('INSERT');
+
+    editor.handleKey(' ');
+    editor.handleKey('w');
+    editor.handleKey('o');
+    editor.handleKey('r');
+    editor.handleKey('l');
+    editor.handleKey('d');
+
+    expect(editor.getBuffer().getText()).toBe(' worldhello');
+    expect(editor.getCursor()).toEqual({ line: 0, character: 6 });
+
+    // Exit insert mode
+    editor.handleKey('Escape');
+    expect(editor.getMode()).toBe('NORMAL');
+    // Cursor moves back one in Normal mode
+    expect(editor.getCursor()).toEqual({ line: 0, character: 5 });
+  });
+
+  it('should support Backspace and Enter in INSERT mode', () => {
+    const editor = new VemEditorState('hello');
+    editor.handleKey('i');
+    editor.handleKey('Backspace'); // At character 0, should do nothing as line 0 has no preceding line
+    expect(editor.getBuffer().getText()).toBe('hello');
+
+    editor.handleKey('l'); // character 1
+    editor.handleKey('Enter'); // should split line
+    expect(editor.getBuffer().getText()).toBe('l\nhello');
+    expect(editor.getCursor()).toEqual({ line: 1, character: 0 });
+
+    editor.handleKey('Backspace'); // should merge lines back
+    expect(editor.getBuffer().getText()).toBe('lhello');
+    expect(editor.getCursor()).toEqual({ line: 0, character: 1 });
+  });
+
+  it('should handle simple motions in NORMAL mode', () => {
+    const editor = new VemEditorState('hello beautiful world');
+    // move right 6 times to reach 'b'
+    for (let i = 0; i < 6; i++) {
+      editor.handleKey('l');
+    }
+    expect(editor.getCursor()).toEqual({ line: 0, character: 6 });
+
+    // move left 2 times
+    editor.handleKey('h');
+    editor.handleKey('h');
+    expect(editor.getCursor()).toEqual({ line: 0, character: 4 });
+
+    // Move to end of line
+    editor.handleKey('$');
+    expect(editor.getCursor()).toEqual({ line: 0, character: 20 });
+  });
+
+  it('should support dw, x, and delete operators', () => {
+    const editor = new VemEditorState('hello beautiful world');
+    // dw at start of line should delete 'hello '
+    editor.handleKey('d');
+    editor.handleKey('w');
+    expect(editor.getBuffer().getText()).toBe('beautiful world');
+    expect(editor.getCursor()).toEqual({ line: 0, character: 0 });
+
+    // x should delete 'b'
+    editor.handleKey('x');
+    expect(editor.getBuffer().getText()).toBe('eautiful world');
+
+    // diw should delete word 'eautiful'
+    editor.handleKey('d');
+    editor.handleKey('i');
+    editor.handleKey('w');
+    expect(editor.getBuffer().getText()).toBe(' world');
+  });
+
+  it('should support undo and redo', () => {
+    const editor = new VemEditorState('hello');
+    editor.handleKey('i');
+    editor.handleKey('!');
+    editor.handleKey('Escape');
+    expect(editor.getBuffer().getText()).toBe('!hello');
+
+    editor.handleKey('u');
+    expect(editor.getBuffer().getText()).toBe('hello');
+
+    editor.handleKey('<C-r>');
+    expect(editor.getBuffer().getText()).toBe('!hello');
+  });
+
+  it('should support VISUAL mode selection and operations', () => {
+    const editor = new VemEditorState('hello world');
+    editor.handleKey('v');
+    expect(editor.getMode()).toBe('VISUAL');
+
+    // Move cursor right 4 times to select 'hello'
+    for (let i = 0; i < 4; i++) {
+      editor.handleKey('l');
+    }
+
+    const selection = editor.getVisualSelection();
+    expect(selection).not.toBeNull();
+    expect(selection!.anchor).toEqual({ line: 0, character: 0 });
+    expect(selection!.active).toEqual({ line: 0, character: 4 });
+
+    // Yank selection
+    editor.handleKey('y');
+    expect(editor.getMode()).toBe('NORMAL');
+    expect(editor.getRegister()).toEqual({
+      text: 'hello',
+      type: 'char',
+    });
+
+    // Move cursor to end, and paste
+    editor.handleKey('$');
+    editor.handleKey('p');
+    expect(editor.getBuffer().getText()).toBe('hello worldhello');
+  });
+
+  describe('COMMAND mode', () => {
+    it('should transition to COMMAND mode and buffer input keys', () => {
+      const editor = new VemEditorState('test');
+      editor.handleKey(':');
+      expect(editor.getMode()).toBe('COMMAND');
+      expect(editor.getCommandText()).toBe('');
+
+      editor.handleKey('w');
+      editor.handleKey('q');
+      expect(editor.getCommandText()).toBe('wq');
+
+      editor.handleKey('Backspace');
+      expect(editor.getCommandText()).toBe('w');
+
+      editor.handleKey('Escape');
+      expect(editor.getMode()).toBe('NORMAL');
+      expect(editor.getCommandText()).toBe('');
+    });
+
+    it('should trigger events on Enter', () => {
+      const editor = new VemEditorState('test');
+
+      let saved = false;
+      editor.onSave(() => {
+        saved = true;
+      });
+
+      let splitDir: string | null = null;
+      editor.onSplit((dir) => {
+        splitDir = dir;
+      });
+
+      // Test :w
+      editor.handleKey(':');
+      editor.handleKey('w');
+      editor.handleKey('Enter');
+      expect(editor.getMode()).toBe('NORMAL');
+      expect(saved).toBe(true);
+
+      // Test :vsp
+      editor.handleKey(':');
+      editor.handleKey('v');
+      editor.handleKey('s');
+      editor.handleKey('p');
+      editor.handleKey('Enter');
+      expect(editor.getMode()).toBe('NORMAL');
+      expect(splitDir).toBe('vertical');
+    });
+  });
+});