@fairyhunter13/opentui-core 0.1.90 → 0.1.92

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

@@ -1,26 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,228 +0,0 @@
-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

@@ -1,251 +0,0 @@
-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()
-  }
-})