@fairyhunter13/opentui-core 0.1.113 → 0.1.114

package/src/renderables/__tests__/Textarea.undo-redo.test.ts

@@ -0,0 +1,383 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test"
+import { createTestRenderer, type TestRenderer, type MockInput } from "../../testing/test-renderer.js"
+import { createTextareaRenderable } from "./renderable-test-utils.js"
+
+let currentRenderer: TestRenderer
+let renderOnce: () => Promise<void>
+let currentMockInput: MockInput
+
+describe("Textarea - Undo/Redo Tests", () => {
+  beforeEach(async () => {
+    ;({
+      renderer: currentRenderer,
+      renderOnce,
+      mockInput: currentMockInput,
+    } = await createTestRenderer({
+      width: 80,
+      height: 24,
+      otherModifiersMode: true,
+    }))
+  })
+
+  afterEach(() => {
+    currentRenderer.destroy()
+  })
+
+  describe("Undo/Redo", () => {
+    it("should delete multiple selected ranges and restore with undo", async () => {
+      const initialText = "Hello World Test"
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: initialText,
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      editor.editBuffer.setCursor(0, 0)
+      for (let i = 0; i < 5; i++) {
+        currentMockInput.pressArrow("right", { shift: true })
+      }
+      expect(editor.hasSelection()).toBe(true)
+      expect(editor.getSelectedText()).toBe("Hello")
+
+      currentMockInput.pressBackspace()
+      expect(editor.plainText).toBe(" World Test")
+      expect(editor.hasSelection()).toBe(false)
+
+      editor.editBuffer.setCursor(0, 0)
+      for (let i = 0; i < 6; i++) {
+        currentMockInput.pressArrow("right", { shift: true })
+      }
+      expect(editor.hasSelection()).toBe(true)
+      expect(editor.getSelectedText()).toBe(" World")
+
+      currentMockInput.pressKey("DELETE")
+      expect(editor.plainText).toBe(" Test")
+      expect(editor.hasSelection()).toBe(false)
+
+      editor.editBuffer.setCursor(0, 0)
+      for (let i = 0; i < 5; i++) {
+        currentMockInput.pressArrow("right", { shift: true })
+      }
+      expect(editor.hasSelection()).toBe(true)
+      expect(editor.getSelectedText()).toBe(" Test")
+
+      currentMockInput.pressBackspace()
+      expect(editor.plainText).toBe("")
+      expect(editor.hasSelection()).toBe(false)
+
+      currentMockInput.pressKey("-", { ctrl: true })
+      expect(editor.plainText).toBe(" Test")
+
+      currentMockInput.pressKey("-", { ctrl: true })
+      expect(editor.plainText).toBe(" World Test")
+
+      currentMockInput.pressKey("-", { ctrl: true })
+      expect(editor.plainText).toBe(initialText)
+    })
+  })
+
+  describe("History - Undo/Redo", () => {
+    it("should undo text insertion", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      // Type "Hello"
+      currentMockInput.pressKey("H")
+      currentMockInput.pressKey("e")
+      currentMockInput.pressKey("l")
+      currentMockInput.pressKey("l")
+      currentMockInput.pressKey("o")
+      expect(editor.plainText).toBe("Hello")
+
+      // Undo
+      editor.undo()
+      expect(editor.plainText).toBe("Hell")
+    })
+
+    it("should redo after undo", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      // Type text
+      currentMockInput.pressKey("T")
+      currentMockInput.pressKey("e")
+      currentMockInput.pressKey("s")
+      currentMockInput.pressKey("t")
+      expect(editor.plainText).toBe("Test")
+
+      // Undo
+      editor.undo()
+      expect(editor.plainText).toBe("Tes")
+
+      // Redo
+      editor.redo()
+      expect(editor.plainText).toBe("Test")
+    })
+
+    it("should handle multiple undo operations", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      // Type characters one by one
+      currentMockInput.pressKey("A")
+      currentMockInput.pressKey("B")
+      currentMockInput.pressKey("C")
+      expect(editor.plainText).toBe("ABC")
+
+      // Undo 3 times
+      editor.undo()
+      expect(editor.plainText).toBe("AB")
+
+      editor.undo()
+      expect(editor.plainText).toBe("A")
+
+      editor.undo()
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should handle Ctrl+- for undo", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      currentMockInput.pressKey("H")
+      currentMockInput.pressKey("i")
+      expect(editor.plainText).toBe("Hi")
+
+      // Ctrl+- to undo
+      currentMockInput.pressKey("-", { ctrl: true })
+      expect(editor.plainText).toBe("H")
+    })
+
+    it("should handle Ctrl+. for redo", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      currentMockInput.pressKey("X")
+      expect(editor.plainText).toBe("X")
+
+      // Undo
+      currentMockInput.pressKey("-", { ctrl: true })
+      expect(editor.plainText).toBe("")
+
+      // Ctrl+. to redo
+      currentMockInput.pressKey(".", { ctrl: true })
+      expect(editor.plainText).toBe("X")
+    })
+
+    it("should handle redo programmatically", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      currentMockInput.pressKey("Y")
+      expect(editor.plainText).toBe("Y")
+
+      editor.undo()
+      expect(editor.plainText).toBe("")
+
+      // Programmatic redo
+      editor.redo()
+      expect(editor.plainText).toBe("Y")
+    })
+
+    it("should undo deletion", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello World",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+
+      // Delete backward
+      currentMockInput.pressBackspace()
+      expect(editor.plainText).toBe("Hello Worl")
+
+      // Undo
+      editor.undo()
+      expect(editor.plainText).toBe("Hello World")
+    })
+
+    it("should undo newline insertion", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+
+      currentMockInput.pressEnter()
+      expect(editor.plainText).toBe("Hello\n")
+
+      // Undo
+      editor.undo()
+      expect(editor.plainText).toBe("Hello")
+    })
+
+    it("should restore cursor position after undo", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 1",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+      expect(editor.logicalCursor.col).toBe(6)
+
+      currentMockInput.pressEnter()
+      currentMockInput.pressKey("L")
+      currentMockInput.pressKey("i")
+      expect(editor.plainText).toBe("Line 1\nLi")
+      expect(editor.logicalCursor.row).toBe(1)
+      expect(editor.logicalCursor.col).toBe(2)
+
+      // Undo last character "i"
+      editor.undo()
+      expect(editor.plainText).toBe("Line 1\nL")
+      expect(editor.logicalCursor.row).toBe(1)
+      expect(editor.logicalCursor.col).toBe(1)
+
+      // Undo "L"
+      editor.undo()
+      expect(editor.plainText).toBe("Line 1\n")
+      expect(editor.logicalCursor.row).toBe(1)
+      expect(editor.logicalCursor.col).toBe(0)
+    })
+
+    it("should handle undo/redo chain", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      // Build up edits
+      currentMockInput.pressKey("1")
+      currentMockInput.pressKey("2")
+      currentMockInput.pressKey("3")
+      expect(editor.plainText).toBe("123")
+
+      // Undo all
+      editor.undo()
+      expect(editor.plainText).toBe("12")
+      editor.undo()
+      expect(editor.plainText).toBe("1")
+      editor.undo()
+      expect(editor.plainText).toBe("")
+
+      // Redo all
+      editor.redo()
+      expect(editor.plainText).toBe("1")
+      editor.redo()
+      expect(editor.plainText).toBe("12")
+      editor.redo()
+      expect(editor.plainText).toBe("123")
+    })
+
+    it("should handle undo after deleteChar", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "ABCDE",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      // Delete "A"
+      currentMockInput.pressKey("DELETE")
+      expect(editor.plainText).toBe("BCDE")
+
+      // Undo
+      editor.undo()
+      expect(editor.plainText).toBe("ABCDE")
+    })
+
+    it("should handle undo after deleteLine", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 1\nLine 2\nLine 3",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(1)
+
+      const beforeDelete = editor.plainText
+
+      // Delete line 2
+      currentMockInput.pressKey("d", { ctrl: true })
+      const afterDelete = editor.plainText
+
+      // Verify delete happened
+      expect(afterDelete).not.toBe(beforeDelete)
+
+      // Undo
+      editor.undo()
+      expect(editor.plainText).toBe(beforeDelete)
+    })
+
+    it("should clear selection on undo", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello World",
+        width: 40,
+        height: 10,
+        selectable: true,
+      })
+
+      editor.focus()
+
+      // Type a character first
+      currentMockInput.pressKey("A")
+      expect(editor.plainText).toBe("AHello World")
+
+      // Undo to get back to original
+      editor.undo()
+      expect(editor.plainText).toBe("Hello World")
+
+      // Make a selection
+      currentMockInput.pressArrow("right", { shift: true })
+      expect(editor.hasSelection()).toBe(true)
+
+      // Undo should clear selection (even though there's nothing to undo now)
+      editor.undo()
+      expect(editor.hasSelection()).toBe(false)
+    })
+  })
+})

package/src/renderables/__tests__/Textarea.visual-lines.test.ts

@@ -0,0 +1,310 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test"
+import { createTestRenderer, type TestRenderer, type MockInput } from "../../testing/test-renderer.js"
+import { createTextareaRenderable } from "./renderable-test-utils.js"
+
+let currentRenderer: TestRenderer
+let renderOnce: () => Promise<void>
+let currentMockInput: MockInput
+
+describe("TextareaRenderable - Visual Line Navigation", () => {
+  beforeEach(async () => {
+    ;({
+      renderer: currentRenderer,
+      renderOnce,
+      mockInput: currentMockInput,
+    } = await createTestRenderer({
+      width: 80,
+      height: 24,
+    }))
+  })
+
+  afterEach(() => {
+    currentRenderer.destroy()
+  })
+
+  describe("without wrapping", () => {
+    it("gotoVisualLineHome should go to start of line", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 40,
+        height: 10,
+        wrapMode: "none",
+      })
+
+      textarea.setText("Hello World")
+      textarea.editBuffer.setCursor(0, 6)
+
+      textarea.gotoVisualLineHome()
+
+      const cursor = textarea.editBuffer.getCursorPosition()
+      expect(cursor.row).toBe(0)
+      expect(cursor.col).toBe(0)
+    })
+
+    it("gotoVisualLineEnd should go to end of line", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 40,
+        height: 10,
+        wrapMode: "none",
+      })
+
+      textarea.setText("Hello World")
+      textarea.editBuffer.setCursor(0, 6)
+
+      textarea.gotoVisualLineEnd()
+
+      const cursor = textarea.editBuffer.getCursorPosition()
+      expect(cursor.row).toBe(0)
+      expect(cursor.col).toBe(11)
+    })
+
+    it("should support selection with visual line home", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 40,
+        height: 10,
+      })
+
+      textarea.setText("Hello World")
+      textarea.editBuffer.setCursor(0, 11)
+
+      textarea.gotoVisualLineHome({ select: true })
+
+      const selection = textarea.getSelection()
+      expect(selection).not.toBeNull()
+      expect(selection!.start).toBe(0)
+      expect(selection!.end).toBe(11)
+      expect(textarea.getSelectedText()).toBe("Hello World")
+    })
+
+    it("should support selection with visual line end", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 40,
+        height: 10,
+      })
+
+      textarea.setText("Hello World")
+      textarea.editBuffer.setCursor(0, 0)
+
+      textarea.gotoVisualLineEnd({ select: true })
+
+      const selection = textarea.getSelection()
+      expect(selection).not.toBeNull()
+      expect(selection!.start).toBe(0)
+      expect(selection!.end).toBe(11)
+      expect(textarea.getSelectedText()).toBe("Hello World")
+    })
+  })
+
+  describe("with wrapping", () => {
+    it("gotoVisualLineHome should go to start of visual line, not logical line", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 20,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      textarea.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+      textarea.editBuffer.setCursor(0, 22)
+
+      textarea.gotoVisualLineHome()
+
+      const cursor = textarea.editBuffer.getCursorPosition()
+      expect(cursor.row).toBe(0)
+      expect(cursor.col).toBe(20)
+    })
+
+    it("gotoVisualLineEnd should go to end of visual line, not logical line", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 20,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      textarea.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+      textarea.editBuffer.setCursor(0, 5)
+
+      textarea.gotoVisualLineEnd()
+
+      const cursor = textarea.editBuffer.getCursorPosition()
+      expect(cursor.row).toBe(0)
+      expect(cursor.col).toBe(19)
+    })
+
+    it("should navigate between visual lines correctly", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 20,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      textarea.setText("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+
+      // First visual line
+      textarea.editBuffer.setCursor(0, 10)
+      textarea.gotoVisualLineHome()
+      expect(textarea.editBuffer.getCursorPosition().col).toBe(0)
+
+      textarea.gotoVisualLineEnd()
+      expect(textarea.editBuffer.getCursorPosition().col).toBe(19)
+
+      // Move to second visual line
+      textarea.editBuffer.moveCursorRight()
+
+      textarea.gotoVisualLineHome()
+      expect(textarea.editBuffer.getCursorPosition().col).toBe(20)
+
+      textarea.gotoVisualLineEnd()
+      const cursor = textarea.editBuffer.getCursorPosition()
+      expect(cursor.col).toBeGreaterThan(20)
+    })
+
+    it("should handle word wrapping correctly", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 20,
+        height: 10,
+        wrapMode: "word",
+      })
+
+      textarea.setText("Hello wonderful world of wrapped text")
+      textarea.editBuffer.setCursor(0, 25)
+
+      const vcursor = textarea.editorView.getVisualCursor()
+      expect(vcursor.visualRow).toBeGreaterThan(0)
+
+      textarea.gotoVisualLineHome()
+      const solCursor = textarea.editBuffer.getCursorPosition()
+      expect(solCursor.col).toBeGreaterThan(0)
+
+      textarea.gotoVisualLineEnd()
+      const eolCursor = textarea.editBuffer.getCursorPosition()
+      expect(eolCursor.col).toBeLessThan(37)
+    })
+
+    it("should select within visual line boundaries", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 20,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      textarea.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+      textarea.editBuffer.setCursor(0, 10)
+
+      textarea.gotoVisualLineEnd({ select: true })
+
+      const selectedText = textarea.getSelectedText()
+      expect(selectedText).toBe("KLMNOPQRS")
+      expect(selectedText.length).toBe(9)
+    })
+  })
+
+  describe("with multi-byte characters", () => {
+    it("should handle wrapped emoji correctly", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 15,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      textarea.setText("🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟")
+
+      // First visual line
+      textarea.editBuffer.setCursor(0, 2)
+      textarea.gotoVisualLineHome()
+      expect(textarea.editBuffer.getCursorPosition().col).toBe(0)
+
+      textarea.gotoVisualLineEnd()
+      const firstLineEnd = textarea.editBuffer.getCursorPosition().col
+      expect(firstLineEnd).toBeGreaterThan(0)
+      expect(firstLineEnd).toBeLessThan(20)
+
+      // Move to second visual line - need to move far enough
+      textarea.editBuffer.setCursor(0, 16)
+      const vcursor = textarea.editorView.getVisualCursor()
+
+      // Only test visual line navigation if we actually moved to second visual line
+      if (vcursor.visualRow > 0) {
+        textarea.gotoVisualLineHome()
+        const secondLineStart = textarea.editBuffer.getCursorPosition().col
+        expect(secondLineStart).toBeGreaterThan(firstLineEnd - 1)
+      }
+    })
+  })
+
+  describe("comparison with logical line navigation", () => {
+    it("visual home should differ from logical home when wrapped", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 20,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      textarea.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+      textarea.editBuffer.setCursor(0, 22)
+
+      textarea.gotoVisualLineHome()
+      const visualHomeCol = textarea.editBuffer.getCursorPosition().col
+      expect(visualHomeCol).toBe(20)
+
+      textarea.editBuffer.setCursor(0, 22)
+      textarea.gotoLineHome()
+      const logicalHomeCol = textarea.editBuffer.getCursorPosition().col
+      expect(logicalHomeCol).toBe(0)
+
+      expect(visualHomeCol).not.toBe(logicalHomeCol)
+    })
+
+    it("visual end should differ from logical end when wrapped", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 20,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      textarea.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+      textarea.editBuffer.setCursor(0, 5)
+
+      textarea.gotoVisualLineEnd()
+      const visualEndCol = textarea.editBuffer.getCursorPosition().col
+      expect(visualEndCol).toBe(19)
+
+      textarea.editBuffer.setCursor(0, 5)
+      textarea.gotoLineEnd()
+      const logicalEndCol = textarea.editBuffer.getCursorPosition().col
+      expect(logicalEndCol).toBe(26)
+
+      expect(visualEndCol).not.toBe(logicalEndCol)
+    })
+
+    it("without wrapping, visual and logical should be the same", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        width: 40,
+        height: 10,
+        wrapMode: "none",
+      })
+
+      textarea.setText("Hello World")
+
+      // Test home
+      textarea.editBuffer.setCursor(0, 6)
+      textarea.gotoVisualLineHome()
+      const visualHomeCol = textarea.editBuffer.getCursorPosition().col
+
+      textarea.editBuffer.setCursor(0, 6)
+      textarea.gotoLineHome()
+      const logicalHomeCol = textarea.editBuffer.getCursorPosition().col
+
+      expect(visualHomeCol).toBe(logicalHomeCol)
+
+      // Test end
+      textarea.editBuffer.setCursor(0, 6)
+      textarea.gotoVisualLineEnd()
+      const visualEndCol = textarea.editBuffer.getCursorPosition().col
+
+      textarea.editBuffer.setCursor(0, 6)
+      textarea.gotoLineEnd()
+      const logicalEndCol = textarea.editBuffer.getCursorPosition().col
+
+      expect(visualEndCol).toBe(logicalEndCol)
+    })
+  })
+})