@fairyhunter13/opentui-core 0.1.88 → 0.1.90

package/src/tests/renderer.cursor.test.ts

@@ -0,0 +1,26 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { createTestRenderer, type TestRenderer } from "../testing"
+
+describe("renderer cursor state", () => {
+  let renderer: TestRenderer
+
+  beforeEach(async () => {
+    ;({ renderer } = await createTestRenderer({ width: 20, height: 10 }))
+  })
+
+  afterEach(() => {
+    renderer.destroy()
+  })
+
+  test("setCursorPosition preserves the terminal cursor style by default", () => {
+    expect(renderer.getCursorState().style).toBe("default")
+
+    renderer.setCursorPosition(4, 2)
+
+    const cursorState = renderer.getCursorState()
+    expect(cursorState.x).toBe(4)
+    expect(cursorState.y).toBe(2)
+    expect(cursorState.visible).toBe(true)
+    expect(cursorState.style).toBe("default")
+  })
+})

package/src/tests/renderer.destroy-during-render.test.ts

@@ -0,0 +1,110 @@
+import { test, expect } from "bun:test"
+import { Renderable } from "../Renderable.js"
+import type { OptimizedBuffer } from "../buffer.js"
+import { createTestRenderer, type TestRenderer } from "../testing/test-renderer.js"
+
+class DestroyingRenderable extends Renderable {
+  protected renderSelf(_buffer: OptimizedBuffer, _deltaTime: number): void {}
+}
+
+test("destroying renderer during frame callback should not crash", async () => {
+  const { renderer } = await createTestRenderer({})
+
+  let destroyedDuringRender = false
+
+  renderer.setFrameCallback(async () => {
+    destroyedDuringRender = true
+    renderer.destroy()
+  })
+
+  renderer.start()
+
+  await new Promise((resolve) => setTimeout(resolve, 100))
+
+  expect(destroyedDuringRender).toBe(true)
+
+  // If we got here without a segfault, the test passes
+})
+
+test("destroying renderer during post-process should not crash", async () => {
+  const { renderer } = await createTestRenderer({})
+
+  let destroyedDuringPostProcess = false
+
+  renderer.addPostProcessFn(() => {
+    destroyedDuringPostProcess = true
+    renderer.destroy()
+  })
+
+  renderer.start()
+
+  await new Promise((resolve) => setTimeout(resolve, 100))
+
+  expect(destroyedDuringPostProcess).toBe(true)
+
+  // If we got here without a segfault, the test passes
+})
+
+test("destroying renderer during root render should not crash", async () => {
+  const { renderer } = await createTestRenderer({})
+
+  let destroyedDuringRender = false
+
+  // Override the root's render method to destroy the renderer
+  const originalRender = renderer.root.render.bind(renderer.root)
+  renderer.root.render = (buffer, deltaTime) => {
+    originalRender(buffer, deltaTime)
+    if (!destroyedDuringRender) {
+      destroyedDuringRender = true
+      renderer.destroy()
+    }
+  }
+
+  renderer.start()
+
+  await new Promise((resolve) => setTimeout(resolve, 100))
+
+  expect(destroyedDuringRender).toBe(true)
+
+  // If we got here without a segfault, the test passes
+})
+
+test("destroying renderer during requestAnimationFrame should not crash", async () => {
+  const { renderer } = await createTestRenderer({})
+
+  let destroyedDuringAnimationFrame = false
+
+  requestAnimationFrame(() => {
+    destroyedDuringAnimationFrame = true
+    renderer.destroy()
+  })
+
+  await new Promise((resolve) => setTimeout(resolve, 100))
+
+  expect(destroyedDuringAnimationFrame).toBe(true)
+})
+
+test("destroying renderer during renderBefore should not crash", async () => {
+  const { renderer } = await createTestRenderer({})
+
+  let destroyedDuringRenderBefore = false
+
+  const renderable = new DestroyingRenderable(renderer, {
+    id: "destroy-render-before",
+    width: 10,
+    height: 1,
+    renderBefore() {
+      if (!destroyedDuringRenderBefore) {
+        destroyedDuringRenderBefore = true
+        renderer.destroy()
+      }
+    },
+  })
+
+  renderer.root.add(renderable)
+  renderer.start()
+
+  await new Promise((resolve) => setTimeout(resolve, 100))
+
+  expect(destroyedDuringRenderBefore).toBe(true)
+})

package/src/tests/renderer.focus-restore.test.ts

@@ -0,0 +1,228 @@
+import { test, expect, beforeEach, afterEach, describe, spyOn } from "bun:test"
+import { Buffer } from "node:buffer"
+import { createTestRenderer, type TestRenderer, type MockInput, type MockMouse } from "../testing/test-renderer"
+import { Renderable } from "../Renderable"
+import { ManualClock } from "../testing/manual-clock"
+
+class TestRenderable extends Renderable {
+  constructor(renderer: TestRenderer, options: any) {
+    super(renderer, options)
+  }
+}
+
+let renderer: TestRenderer
+let mockInput: MockInput
+let mockMouse: MockMouse
+let renderOnce: () => Promise<void>
+let restoreSpy: ReturnType<typeof spyOn>
+let clock: ManualClock
+
+beforeEach(async () => {
+  clock = new ManualClock()
+  ;({ renderer, mockInput, mockMouse, renderOnce } = await createTestRenderer({
+    useMouse: true,
+    clock,
+  }))
+
+  // @ts-expect-error - testing private renderer internals
+  restoreSpy = spyOn(renderer.lib, "restoreTerminalModes")
+})
+
+afterEach(() => {
+  restoreSpy.mockRestore()
+  renderer.destroy()
+})
+
+describe("focus restore - terminal mode re-enable on focus-in", () => {
+  test("restoreTerminalModes is NOT called on focus-in without prior blur", async () => {
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    expect(restoreSpy).toHaveBeenCalledTimes(0)
+  })
+
+  test("restoreTerminalModes is called once after blur then focus-in", async () => {
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    expect(restoreSpy).toHaveBeenCalledTimes(1)
+  })
+
+  test("restoreTerminalModes is NOT called on blur event", async () => {
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    expect(restoreSpy).toHaveBeenCalledTimes(0)
+  })
+
+  test("restoreTerminalModes is called before focus event is emitted after blur", async () => {
+    const callOrder: string[] = []
+
+    restoreSpy.mockImplementation(() => {
+      callOrder.push("restoreTerminalModes")
+    })
+
+    renderer.on("focus", () => {
+      callOrder.push("focus-event")
+    })
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    expect(callOrder).toEqual(["restoreTerminalModes", "focus-event"])
+  })
+
+  test("repeated focus-in events only restore once per blur cycle", async () => {
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    expect(restoreSpy).toHaveBeenCalledTimes(1)
+  })
+
+  test("multiple blur/focus cycles each trigger one restore", async () => {
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    expect(restoreSpy).toHaveBeenCalledTimes(2)
+  })
+
+  test("focus-in emits focus event on the renderer", async () => {
+    const events: string[] = []
+
+    renderer.on("focus", () => {
+      events.push("focus")
+    })
+
+    renderer.on("blur", () => {
+      events.push("blur")
+    })
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    expect(events).toEqual(["focus", "blur"])
+  })
+
+  test("focus events do not trigger keypress events", async () => {
+    const keypresses: any[] = []
+
+    renderer.keyInput.on("keypress", (event) => {
+      keypresses.push(event)
+    })
+
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+
+    expect(keypresses).toHaveLength(0)
+  })
+
+  test("mouse events work after focus restore cycle", async () => {
+    renderer.start()
+
+    const target = new TestRenderable(renderer, {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: renderer.width,
+      height: renderer.height,
+    })
+    renderer.root.add(target)
+    await renderOnce()
+
+    let mouseEventCount = 0
+    target.onMouse = () => {
+      mouseEventCount++
+    }
+
+    // Verify mouse works initially
+    await mockMouse.click(5, 5)
+    expect(mouseEventCount).toBeGreaterThan(0)
+
+    const countBefore = mouseEventCount
+
+    // Simulate focus loss and regain
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    // Verify restoreTerminalModes was called
+    expect(restoreSpy).toHaveBeenCalledTimes(1)
+
+    // Verify mouse still works after focus restore
+    await mockMouse.click(5, 5)
+    expect(mouseEventCount).toBeGreaterThan(countBefore)
+
+    renderer.root.remove(target.id)
+  })
+
+  test("keyboard input works after focus restore cycle", async () => {
+    renderer.start()
+
+    let keyEventCount = 0
+    const onKeypress = () => {
+      keyEventCount++
+    }
+    renderer.keyInput.on("keypress", onKeypress)
+
+    // Verify keyboard works initially
+    mockInput.pressKey("a")
+    clock.advance(15)
+    expect(keyEventCount).toBeGreaterThan(0)
+
+    const countBefore = keyEventCount
+
+    // Simulate focus loss and regain
+    renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+    clock.advance(15)
+    renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    clock.advance(15)
+
+    // Verify keyboard still works after focus restore
+    mockInput.pressKey("b")
+    clock.advance(15)
+    expect(keyEventCount).toBeGreaterThan(countBefore)
+
+    renderer.keyInput.off("keypress", onKeypress)
+  })
+
+  test("rapid focus toggle does not cause issues", async () => {
+    // Simulate rapid alt-tab back and forth
+    for (let i = 0; i < 10; i++) {
+      renderer.stdin.emit("data", Buffer.from("\x1b[O"))
+      renderer.stdin.emit("data", Buffer.from("\x1b[I"))
+    }
+    clock.advance(15)
+
+    expect(restoreSpy).toHaveBeenCalledTimes(10)
+  })
+})

package/src/tests/renderer.focus.test.ts

@@ -0,0 +1,251 @@
+import { test, expect, beforeEach, afterEach } from "bun:test"
+import { createTestRenderer, MouseButtons, type MockMouse, type TestRenderer } from "../testing.js"
+import { ScrollBoxRenderable } from "../renderables/ScrollBox.js"
+import { BoxRenderable } from "../renderables/Box.js"
+import { TextRenderable } from "../renderables/Text.js"
+
+let testRenderer: TestRenderer
+let mockMouse: MockMouse
+
+beforeEach(async () => {
+  ;({ renderer: testRenderer, mockMouse } = await createTestRenderer({
+    width: 50,
+    height: 30,
+  }))
+})
+
+afterEach(() => {
+  testRenderer.destroy()
+})
+
+test("click on focusable element focuses it", async () => {
+  const scrollbox = new ScrollBoxRenderable(testRenderer, {
+    id: "focusable-box",
+    width: 20,
+    height: 10,
+  })
+  testRenderer.root.add(scrollbox)
+  await testRenderer.idle()
+
+  expect(scrollbox.focused).toBe(false)
+
+  await mockMouse.click(scrollbox.x + 1, scrollbox.y + 1)
+
+  expect(scrollbox.focused).toBe(true)
+})
+
+test("click on child bubbles up to focusable parent", async () => {
+  const scrollbox = new ScrollBoxRenderable(testRenderer, {
+    id: "parent-box",
+    width: 20,
+    height: 10,
+  })
+  testRenderer.root.add(scrollbox)
+
+  const text = new TextRenderable(testRenderer, {
+    id: "child-text",
+    content: "Click me",
+  })
+  scrollbox.add(text)
+  await testRenderer.idle()
+
+  expect(scrollbox.focused).toBe(false)
+
+  await mockMouse.click(text.x + 1, text.y)
+
+  expect(scrollbox.focused).toBe(true)
+})
+
+test("click on non-focusable with no focusable parent does nothing", async () => {
+  const box = new BoxRenderable(testRenderer, {
+    id: "plain-box",
+    width: 20,
+    height: 10,
+  })
+  testRenderer.root.add(box)
+  await testRenderer.idle()
+
+  expect(box.focusable).toBe(false)
+
+  await mockMouse.click(box.x + 1, box.y + 1)
+
+  expect(box.focused).toBe(false)
+})
+
+test("preventDefault on mousedown prevents auto-focus", async () => {
+  const scrollbox = new ScrollBoxRenderable(testRenderer, {
+    id: "focusable-box",
+    width: 20,
+    height: 10,
+    onMouseDown: (event) => {
+      event.preventDefault()
+    },
+  })
+  testRenderer.root.add(scrollbox)
+  await testRenderer.idle()
+
+  expect(scrollbox.focused).toBe(false)
+
+  await mockMouse.click(scrollbox.x + 1, scrollbox.y + 1)
+
+  expect(scrollbox.focused).toBe(false)
+})
+
+test("mousedown handler is only called once per click", async () => {
+  let mouseDownCount = 0
+  const box = new BoxRenderable(testRenderer, {
+    id: "click-box",
+    width: 20,
+    height: 10,
+    onMouseDown: () => {
+      mouseDownCount++
+    },
+  })
+  testRenderer.root.add(box)
+  await testRenderer.idle()
+
+  await mockMouse.click(box.x + 1, box.y + 1)
+
+  expect(mouseDownCount).toBe(1)
+})
+
+test("non-left click does not auto-focus", async () => {
+  const scrollbox = new ScrollBoxRenderable(testRenderer, {
+    id: "focusable-box",
+    width: 20,
+    height: 10,
+  })
+  testRenderer.root.add(scrollbox)
+  await testRenderer.idle()
+
+  await mockMouse.click(scrollbox.x + 1, scrollbox.y + 1, MouseButtons.RIGHT)
+  expect(scrollbox.focused).toBe(false)
+
+  await mockMouse.click(scrollbox.x + 2, scrollbox.y + 2, MouseButtons.MIDDLE)
+  expect(scrollbox.focused).toBe(false)
+})
+
+test("preventDefault on ancestor blocks auto-focus", async () => {
+  let childDown = false
+  const parent = new BoxRenderable(testRenderer, {
+    id: "focus-parent",
+    position: "absolute",
+    left: 2,
+    top: 2,
+    width: 20,
+    height: 10,
+    focusable: true,
+    onMouseDown: (event) => {
+      event.preventDefault()
+    },
+  })
+  const child = new BoxRenderable(testRenderer, {
+    id: "focus-child",
+    position: "absolute",
+    left: 1,
+    top: 1,
+    width: 6,
+    height: 3,
+    onMouseDown: () => {
+      childDown = true
+    },
+  })
+  parent.add(child)
+  testRenderer.root.add(parent)
+  await testRenderer.idle()
+
+  await mockMouse.click(child.x + 1, child.y + 1)
+
+  expect(childDown).toBe(true)
+  expect(parent.focused).toBe(false)
+  expect(child.focused).toBe(false)
+})
+
+test("dragging over focusable target does not auto-focus", async () => {
+  const start = new BoxRenderable(testRenderer, {
+    id: "drag-start",
+    position: "absolute",
+    left: 1,
+    top: 1,
+    width: 6,
+    height: 4,
+  })
+  const focusable = new BoxRenderable(testRenderer, {
+    id: "drag-focusable",
+    position: "absolute",
+    left: 12,
+    top: 1,
+    width: 6,
+    height: 4,
+    focusable: true,
+  })
+  testRenderer.root.add(start)
+  testRenderer.root.add(focusable)
+  await testRenderer.idle()
+
+  await mockMouse.pressDown(start.x + 1, start.y + 1)
+  await mockMouse.moveTo(focusable.x + 1, focusable.y + 1)
+  await mockMouse.release(focusable.x + 1, focusable.y + 1)
+
+  expect(focusable.focused).toBe(false)
+})
+
+test("clicking empty space does not auto-focus", async () => {
+  const box = new BoxRenderable(testRenderer, {
+    id: "focusable-box",
+    position: "absolute",
+    left: 1,
+    top: 1,
+    width: 8,
+    height: 4,
+    focusable: true,
+  })
+  testRenderer.root.add(box)
+  await testRenderer.idle()
+
+  await mockMouse.click(testRenderer.width - 1, testRenderer.height - 1)
+
+  expect(box.focused).toBe(false)
+})
+
+test("autoFocus=false prevents click focus changes", async () => {
+  const { renderer, mockMouse } = await createTestRenderer({
+    width: 50,
+    height: 30,
+    autoFocus: false,
+  })
+
+  try {
+    const first = new BoxRenderable(renderer, {
+      id: "focus-first",
+      position: "absolute",
+      left: 1,
+      top: 1,
+      width: 8,
+      height: 4,
+      focusable: true,
+    })
+    const second = new BoxRenderable(renderer, {
+      id: "focus-second",
+      position: "absolute",
+      left: 12,
+      top: 1,
+      width: 8,
+      height: 4,
+      focusable: true,
+    })
+    renderer.root.add(first)
+    renderer.root.add(second)
+    await renderer.idle()
+
+    first.focus()
+    expect(first.focused).toBe(true)
+
+    await mockMouse.click(second.x + 1, second.y + 1)
+
+    expect(first.focused).toBe(true)
+    expect(second.focused).toBe(false)
+  } finally {
+    renderer.destroy()
+  }
+})