ep_vim 0.5.0 → 0.6.0

package/README.md

@@ -6,7 +6,7 @@ A vim-mode plugin for [Etherpad](https://etherpad.org/). Adds modal editing with
 
 - **Modal editing** — normal, insert, and visual (char + line) modes
 - **Motions** — `h` `j` `k` `l`, `w` `b` `e`, `0` `$` `^`, `gg` `G`, `f`/`F`/`t`/`T` char search
-- **Operators** — `d`, `c`, `y` with motion combinations (`dw`, `ce`, `y$`, etc.) and text objects (`ciw`, `diw`, `yiw`)
+- **Operators** — `d`, `c`, `y` with motion combinations (`dw`, `ce`, `y$`, etc.) and text objects (`ciw`, `da"`, `yi(` etc.)
 - **Line operations** — `dd`, `cc`, `yy`, `J` (join), `Y` (yank line)
 - **Put** — `p` / `P` with linewise and characterwise register handling
 - **Editing** — `x`, `r`, `s`, `S`, `C`, `o`, `O`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ep_vim",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Vim-mode plugin for Etherpad with modal editing, motions, and operators",
   "author": {
     "name": "Seth Rothschild",

package/static/js/index.js

@@ -11,9 +11,9 @@ const {
   charSearchPos,
   motionRange,
   charMotionRange,
-  innerWordRange,
-  innerQuoteRange,
-  innerBracketRange,
+  textWordRange,
+  textQuoteRange,
+  textBracketRange,
   getVisualSelection,
   paragraphForward,
   paragraphBackward,
@@ -40,11 +40,11 @@ let lastCharSearch = null;
 const QUOTE_CHARS = new Set(['"', "'"]);
 const BRACKET_CHARS = new Set(["(", ")", "{", "}", "[", "]"]);
 
-const innerTextObjectRange = (key, lineText, char) => {
-  if (key === "w") return innerWordRange(lineText, char);
-  if (QUOTE_CHARS.has(key)) return innerQuoteRange(lineText, char, key);
-  if (BRACKET_CHARS.has(key)) return innerBracketRange(lineText, char, key);
-  return null;
+const textObjectRange = (key, lineText, char, type) => {
+  if (key === "w") return textWordRange(lineText, char);
+  if (QUOTE_CHARS.has(key)) return textQuoteRange(lineText, char, key, type);
+  if (BRACKET_CHARS.has(key))
+    return textBracketRange(lineText, char, key, type);
 };
 
 // --- Count helpers ---
@@ -148,6 +148,23 @@ const handleVisualKey = (rep, editorInfo, key) => {
   const curChar = visualCursor[1];
   const lineText = getLineText(rep, curLine);
 
+  if (key === "i" || key === "a") {
+    pendingKey = key;
+    return true;
+  }
+
+  if (pendingKey === "i" || pendingKey === "a") {
+    const range = textObjectRange(key, lineText, curChar, pendingKey);
+    pendingKey = null;
+    if (range) {
+      visualAnchor = [curLine, range.start];
+      visualCursor = [curLine, range.end];
+      setVisualMode("char");
+      updateVisualSelection(editorInfo, rep);
+    }
+    return true;
+  }
+
   if (key >= "1" && key <= "9") {
     countBuffer += key;
     return true;
@@ -559,9 +576,9 @@ const handleNormalKey = (rep, editorInfo, key) => {
     return true;
   }
 
-  if (pendingKey === "di") {
+  if (pendingKey === "di" || pendingKey === "da") {
+    const range = textObjectRange(key, lineText, char, pendingKey[1]);
     pendingKey = null;
-    const range = innerTextObjectRange(key, lineText, char);
     if (range) {
       setRegister(lineText.slice(range.start, range.end));
       replaceRange(editorInfo, [line, range.start], [line, range.end], "");
@@ -666,9 +683,9 @@ const handleNormalKey = (rep, editorInfo, key) => {
     return true;
   }
 
-  if (pendingKey === "ci") {
+  if (pendingKey === "ci" || pendingKey === "ca") {
+    const range = textObjectRange(key, lineText, char, pendingKey[1]);
     pendingKey = null;
-    const range = innerTextObjectRange(key, lineText, char);
     if (range) {
       setRegister(lineText.slice(range.start, range.end));
       replaceRange(editorInfo, [line, range.start], [line, range.end], "");
@@ -710,8 +727,8 @@ const handleNormalKey = (rep, editorInfo, key) => {
   }
 
   if (pendingKey === "yi") {
+    const range = textObjectRange(key, lineText, char, pendingKey[1]);
     pendingKey = null;
-    const range = innerTextObjectRange(key, lineText, char);
     if (range) {
       setRegister(lineText.slice(range.start, range.end));
     }
@@ -1171,6 +1188,16 @@ exports.aceKeyEvent = (_hookName, { evt, rep, editorInfo }) => {
     return handled || true;
   }
 
+  if (
+    !insertMode &&
+    visualMode !== null &&
+    (evt.key === "i" || evt.key === "a")
+  ) {
+    const handled = handleVisualKey(rep, editorInfo, evt.key);
+    evt.preventDefault();
+    return handled || true;
+  }
+
   if (!insertMode && evt.key === "i") {
     const [line, char] = rep.selStart;
     desiredColumn = null;

package/static/js/vim-core.js

@@ -208,7 +208,7 @@ const getVisualSelection = (visualMode, visualAnchor, visualCursor, rep) => {
   return [visualCursor, visualAnchor];
 };
 
-const innerWordRange = (lineText, char) => {
+const textWordRange = (lineText, char, type) => {
   if (lineText.length === 0 || char >= lineText.length) return null;
   const ch = lineText[char];
   let start = char;
@@ -233,7 +233,16 @@ const innerWordRange = (lineText, char) => {
     )
       end++;
   }
-  return { start, end: end + 1 };
+  if (type === "i") {
+    return { start, end: end + 1 };
+  } else {
+    if (isWhitespace(ch)) {
+      while (start > 0 && isWhitespace(lineText[start - 1])) start--;
+      while (end + 1 < lineText.length && isWhitespace(lineText[end + 1]))
+        end++;
+    }
+    return { start, end: end + 1 };
+  }
 };
 
 const BRACKET_PAIRS = {
@@ -246,16 +255,20 @@ const BRACKET_PAIRS = {
 };
 const OPEN_BRACKETS = new Set(["(", "{", "["]);
 
-const innerQuoteRange = (lineText, char, quote) => {
+const textQuoteRange = (lineText, char, quote, type) => {
   const first = lineText.indexOf(quote);
   if (first === -1) return null;
   const second = lineText.indexOf(quote, first + 1);
   if (second === -1) return null;
   if (char < first || char > second) return null;
-  return { start: first + 1, end: second };
+  if (type === "i") {
+    return { start: first + 1, end: second };
+  } else {
+    return { start: first, end: second + 1 };
+  }
 };
 
-const innerBracketRange = (lineText, char, bracket) => {
+const textBracketRange = (lineText, char, bracket, type) => {
   const open = OPEN_BRACKETS.has(bracket) ? bracket : BRACKET_PAIRS[bracket];
   const close = BRACKET_PAIRS[open];
   let depth = 0;
@@ -275,14 +288,20 @@ const innerBracketRange = (lineText, char, bracket) => {
   for (let i = openPos + 1; i < lineText.length; i++) {
     if (lineText[i] === open) depth++;
     if (lineText[i] === close) {
-      if (depth === 0) return { start: openPos + 1, end: i };
+      if (depth === 0) {
+        if (type === "i") {
+          return { start: openPos + 1, end: i };
+        } else {
+          return { start: openPos, end: i + 1 };
+        }
+      }
       depth--;
     }
   }
   return null;
 };
 
-const getTextInRange = (rep, start, end) => {
+const getTextInRange = (rep, start, end, type) => {
   if (start[0] === end[0]) {
     return getLineText(rep, start[0]).slice(start[1], end[1]);
   }
@@ -310,9 +329,9 @@ module.exports = {
   charSearchPos,
   motionRange,
   charMotionRange,
-  innerWordRange,
-  innerQuoteRange,
-  innerBracketRange,
+  textWordRange,
+  textQuoteRange,
+  textBracketRange,
   getVisualSelection,
   paragraphForward,
   paragraphBackward,

package/static/js/vim-core.test.js

@@ -17,9 +17,9 @@ const {
   charSearchPos,
   motionRange,
   charMotionRange,
-  innerWordRange,
-  innerQuoteRange,
-  innerBracketRange,
+  textWordRange,
+  textQuoteRange,
+  textBracketRange,
   getVisualSelection,
   paragraphForward,
   paragraphBackward,
@@ -360,185 +360,203 @@ describe("charMotionRange", () => {
 
 describe("innerWordRange", () => {
   it("selects the whole word when cursor is in the middle", () => {
-    assert.deepEqual(innerWordRange("hello world", 2), { start: 0, end: 5 });
+    assert.deepEqual(textWordRange("hello world", 2, "i"), {
+      start: 0,
+      end: 5,
+    });
   });
 
   it("selects the whole word when cursor is at the start", () => {
-    assert.deepEqual(innerWordRange("hello world", 0), { start: 0, end: 5 });
+    assert.deepEqual(textWordRange("hello world", 0, "i"), {
+      start: 0,
+      end: 5,
+    });
   });
 
   it("selects the whole word when cursor is at the end", () => {
-    assert.deepEqual(innerWordRange("hello world", 4), { start: 0, end: 5 });
+    assert.deepEqual(textWordRange("hello world", 4, "i"), {
+      start: 0,
+      end: 5,
+    });
   });
 
   it("selects a word in the middle of a line", () => {
-    assert.deepEqual(innerWordRange("hello world foo", 6), {
+    assert.deepEqual(textWordRange("hello world foo", 6, "i"), {
       start: 6,
       end: 11,
     });
   });
 
   it("selects whitespace when cursor is on whitespace", () => {
-    assert.deepEqual(innerWordRange("hello   world", 6), { start: 5, end: 8 });
+    assert.deepEqual(textWordRange("hello   world", 6, "i"), {
+      start: 5,
+      end: 8,
+    });
   });
 
   it("selects a run of punctuation", () => {
-    assert.deepEqual(innerWordRange("foo...bar", 3), { start: 3, end: 6 });
+    assert.deepEqual(textWordRange("foo...bar", 3, "i"), { start: 3, end: 6 });
   });
 
   it("returns null for empty string", () => {
-    assert.equal(innerWordRange("", 0), null);
+    assert.equal(textWordRange("", 0, "i"), null);
   });
 
   it("returns null when char is out of bounds", () => {
-    assert.equal(innerWordRange("hello", 10), null);
+    assert.equal(textWordRange("hello", 10, "i"), null);
   });
 
   it("selects a single-char word", () => {
-    assert.deepEqual(innerWordRange("a b c", 2), { start: 2, end: 3 });
+    assert.deepEqual(textWordRange("a b c", 2, "i"), { start: 2, end: 3 });
   });
 
   it("selects word with underscores", () => {
-    assert.deepEqual(innerWordRange("foo_bar baz", 3), { start: 0, end: 7 });
+    assert.deepEqual(textWordRange("foo_bar baz", 3, "i"), {
+      start: 0,
+      end: 7,
+    });
   });
 
   it("selects word with digits", () => {
-    assert.deepEqual(innerWordRange("abc123 xyz", 4), { start: 0, end: 6 });
+    assert.deepEqual(textWordRange("abc123 xyz", 4, "i"), { start: 0, end: 6 });
   });
 
   it("selects single whitespace char between words", () => {
-    assert.deepEqual(innerWordRange("hello world", 5), { start: 5, end: 6 });
+    assert.deepEqual(textWordRange("hello world", 5, "i"), {
+      start: 5,
+      end: 6,
+    });
   });
 
   it("selects last word on line", () => {
-    assert.deepEqual(innerWordRange("foo bar", 4), { start: 4, end: 7 });
+    assert.deepEqual(textWordRange("foo bar", 4, "i"), { start: 4, end: 7 });
   });
 
   it("handles cursor at last char of line", () => {
-    assert.deepEqual(innerWordRange("hello", 4), { start: 0, end: 5 });
+    assert.deepEqual(textWordRange("hello", 4, "i"), { start: 0, end: 5 });
   });
 
   it("selects a single-char line", () => {
-    assert.deepEqual(innerWordRange("x", 0), { start: 0, end: 1 });
+    assert.deepEqual(textWordRange("x", 0, "i"), { start: 0, end: 1 });
   });
 });
 
-describe("innerQuoteRange", () => {
+describe("textQuoteRange", () => {
   it("selects content between double quotes", () => {
-    assert.deepEqual(innerQuoteRange('say "hello" ok', 6, '"'), {
+    assert.deepEqual(textQuoteRange('say "hello" ok', 6, '"', "i"), {
       start: 5,
       end: 10,
     });
   });
 
   it("works when cursor is on the opening quote", () => {
-    assert.deepEqual(innerQuoteRange('say "hello" ok', 4, '"'), {
+    assert.deepEqual(textQuoteRange('say "hello" ok', 4, '"', "i"), {
       start: 5,
       end: 10,
     });
   });
 
   it("works when cursor is on the closing quote", () => {
-    assert.deepEqual(innerQuoteRange('say "hello" ok', 10, '"'), {
+    assert.deepEqual(textQuoteRange('say "hello" ok', 10, '"', "i"), {
       start: 5,
       end: 10,
     });
   });
 
   it("returns null when no quotes exist", () => {
-    assert.equal(innerQuoteRange("no quotes here", 3, '"'), null);
+    assert.equal(textQuoteRange("no quotes here", 3, '"', "i"), null);
   });
 
   it("returns null when only one quote exists", () => {
-    assert.equal(innerQuoteRange('say "hello', 6, '"'), null);
+    assert.equal(textQuoteRange('say "hello', 6, '"', "i"), null);
   });
 
   it("returns null when cursor is outside the quotes", () => {
-    assert.equal(innerQuoteRange('say "hello" ok', 12, '"'), null);
+    assert.equal(textQuoteRange('say "hello" ok', 12, '"', "i"), null);
   });
 
   it("works with single quotes", () => {
-    assert.deepEqual(innerQuoteRange("say 'fine' ok", 7, "'"), {
+    assert.deepEqual(textQuoteRange("say 'fine' ok", 7, "'", "i"), {
       start: 5,
       end: 9,
     });
   });
 
   it("selects empty content between adjacent quotes", () => {
-    assert.deepEqual(innerQuoteRange('foo "" bar', 4, '"'), {
+    assert.deepEqual(textQuoteRange('foo "" bar', 4, '"', "i"), {
       start: 5,
       end: 5,
     });
   });
 });
 
-describe("innerBracketRange", () => {
+describe("textBracketRange", () => {
   it("selects content inside parentheses", () => {
-    assert.deepEqual(innerBracketRange("foo(bar)baz", 5, "("), {
+    assert.deepEqual(textBracketRange("foo(bar)baz", 5, "(", "i"), {
       start: 4,
       end: 7,
     });
   });
 
   it("works with closing bracket as argument", () => {
-    assert.deepEqual(innerBracketRange("foo(bar)baz", 5, ")"), {
+    assert.deepEqual(textBracketRange("foo(bar)baz", 5, ")", "i"), {
       start: 4,
       end: 7,
     });
   });
 
   it("selects content inside curly braces", () => {
-    assert.deepEqual(innerBracketRange("if {yes} no", 5, "{"), {
+    assert.deepEqual(textBracketRange("if {yes} no", 5, "{", "i"), {
       start: 4,
       end: 7,
     });
   });
 
   it("selects content inside square brackets", () => {
-    assert.deepEqual(innerBracketRange("a[bc]d", 2, "["), {
+    assert.deepEqual(textBracketRange("a[bc]d", 2, "[", "i"), {
       start: 2,
       end: 4,
     });
   });
 
   it("handles nested brackets", () => {
-    assert.deepEqual(innerBracketRange("(a(b)c)", 3, "("), {
+    assert.deepEqual(textBracketRange("(a(b)c)", 3, "(", "i"), {
       start: 3,
       end: 4,
     });
   });
 
   it("handles nested brackets from outer position", () => {
-    assert.deepEqual(innerBracketRange("(a(b)c)", 1, "("), {
+    assert.deepEqual(textBracketRange("(a(b)c)", 1, "(", "i"), {
       start: 1,
       end: 6,
     });
   });
 
   it("returns null when no matching brackets", () => {
-    assert.equal(innerBracketRange("no brackets", 3, "("), null);
+    assert.equal(textBracketRange("no brackets", 3, "(", "i"), null);
   });
 
   it("returns null when cursor is outside brackets", () => {
-    assert.equal(innerBracketRange("x (foo) y", 0, "("), null);
+    assert.equal(textBracketRange("x (foo) y", 0, "(", "i"), null);
   });
 
   it("selects empty content between adjacent brackets", () => {
-    assert.deepEqual(innerBracketRange("foo()bar", 4, "("), {
+    assert.deepEqual(textBracketRange("foo()bar", 4, "(", "i"), {
       start: 4,
       end: 4,
     });
   });
 
   it("works when cursor is on the opening bracket", () => {
-    assert.deepEqual(innerBracketRange("(hello)", 0, "("), {
+    assert.deepEqual(textBracketRange("(hello)", 0, "(", "i"), {
       start: 1,
       end: 6,
     });
   });
 
   it("works when cursor is on the closing bracket", () => {
-    assert.deepEqual(innerBracketRange("(hello)", 6, ")"), {
+    assert.deepEqual(textBracketRange("(hello)", 6, ")", "i"), {
       start: 1,
       end: 6,
     });