@xincli/opentui-core 0.4.6 → 0.4.7

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

@@ -1,329 +0,0 @@
-import { test, expect, beforeEach, afterEach, describe } from "bun:test"
-import { CliRenderEvents } from "../renderer.js"
-import { createTestRenderer, MouseButtons, type MockMouse, type TestRenderer } from "../testing.js"
-import { ScrollBoxRenderable } from "../renderables/ScrollBox.js"
-import { BoxRenderable } from "../renderables/Box.js"
-import { InputRenderable } from "../renderables/Input.js"
-import { TextareaRenderable } from "../renderables/Textarea.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()
-  }
-})
-
-test("focused_editor event emits on editor focus changes", async () => {
-  const events: Array<[string | null, string | null]> = []
-  const box = new BoxRenderable(testRenderer, {
-    id: "plain-box",
-    width: 10,
-    height: 2,
-    focusable: true,
-  })
-  const textarea = new TextareaRenderable(testRenderer, {
-    id: "editor-a",
-    width: 20,
-    height: 3,
-  })
-  const input = new InputRenderable(testRenderer, {
-    id: "editor-b",
-    width: 20,
-  })
-
-  testRenderer.on(CliRenderEvents.FOCUSED_EDITOR, (current, previous) => {
-    events.push([current?.id ?? null, previous?.id ?? null])
-  })
-
-  testRenderer.root.add(box)
-  testRenderer.root.add(textarea)
-  testRenderer.root.add(input)
-  await testRenderer.idle()
-
-  textarea.focus()
-  box.focus()
-  input.focus()
-  input.focus()
-
-  expect(events).toEqual([
-    ["editor-a", null],
-    [null, "editor-a"],
-    ["editor-b", null],
-  ])
-  expect(testRenderer.currentFocusedEditor?.id).toBe("editor-b")
-})
-
-test("focused_renderable event emits once per focus change and direct blur", async () => {
-  const events: Array<[string | null, string | null]> = []
-  const first = new BoxRenderable(testRenderer, {
-    id: "first-box",
-    width: 10,
-    height: 2,
-    focusable: true,
-  })
-  const second = new BoxRenderable(testRenderer, {
-    id: "second-box",
-    width: 10,
-    height: 2,
-    focusable: true,
-  })
-
-  testRenderer.on(CliRenderEvents.FOCUSED_RENDERABLE, (current, previous) => {
-    events.push([current?.id ?? null, previous?.id ?? null])
-  })
-
-  testRenderer.root.add(first)
-  testRenderer.root.add(second)
-  await testRenderer.idle()
-
-  first.focus()
-  second.focus()
-  second.blur()
-
-  expect(events).toEqual([
-    ["first-box", null],
-    ["second-box", "first-box"],
-    [null, "second-box"],
-  ])
-  expect(testRenderer.currentFocusedRenderable).toBeNull()
-})

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

@@ -1,219 +0,0 @@
-import { test, expect, beforeEach, afterEach } from "bun:test"
-import { createTestRenderer, type TestRenderer } from "../testing/test-renderer.js"
-import { RendererControlState } from "../renderer.js"
-
-let renderer: TestRenderer
-let renderOnce: () => Promise<void>
-
-async function expectIdleToResolveImmediately(renderer: TestRenderer): Promise<void> {
-  const idlePromise = renderer.idle()
-  let resolved = false
-
-  idlePromise.then(() => {
-    resolved = true
-  })
-
-  await Promise.resolve()
-
-  expect(resolved).toBe(true)
-  await idlePromise
-}
-
-beforeEach(async () => {
-  ;({ renderer, renderOnce } = await createTestRenderer({}))
-})
-
-afterEach(() => {
-  renderer.destroy()
-})
-
-test("idle() resolves immediately when renderer is already idle", async () => {
-  expect(renderer.controlState).toBe(RendererControlState.IDLE)
-  expect(renderer.isRunning).toBe(false)
-
-  await expectIdleToResolveImmediately(renderer)
-})
-
-test("idle() waits for running renderer to stop", async () => {
-  renderer.start()
-  expect(renderer.isRunning).toBe(true)
-
-  const idlePromise = renderer.idle()
-
-  await new Promise((resolve) => setTimeout(resolve, 50))
-
-  renderer.stop()
-
-  await idlePromise
-
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() waits for paused renderer after requestRender()", async () => {
-  renderer.pause()
-  expect(renderer.isRunning).toBe(false)
-
-  renderer.requestRender()
-
-  const idlePromise = renderer.idle()
-
-  await idlePromise
-
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() resolves immediately after requestRender() completes", async () => {
-  renderer.requestRender()
-
-  await renderer.idle()
-
-  await expectIdleToResolveImmediately(renderer)
-})
-
-test("multiple idle() calls all resolve when renderer becomes idle", async () => {
-  renderer.start()
-
-  const idlePromise1 = renderer.idle()
-  const idlePromise2 = renderer.idle()
-  const idlePromise3 = renderer.idle()
-
-  await new Promise((resolve) => setTimeout(resolve, 50))
-
-  renderer.stop()
-
-  await Promise.all([idlePromise1, idlePromise2, idlePromise3])
-
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() resolves when AUTO_STARTED renderer drops all live requests", async () => {
-  renderer.requestLive()
-  expect(renderer.controlState).toBe(RendererControlState.AUTO_STARTED)
-  expect(renderer.isRunning).toBe(true)
-
-  const idlePromise = renderer.idle()
-
-  renderer.dropLive()
-
-  await idlePromise
-
-  expect(renderer.controlState).toBe(RendererControlState.IDLE)
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() resolves after explicit pause", async () => {
-  renderer.start()
-  expect(renderer.isRunning).toBe(true)
-
-  const idlePromise = renderer.idle()
-
-  renderer.pause()
-
-  await idlePromise
-
-  expect(renderer.controlState).toBe(RendererControlState.EXPLICIT_PAUSED)
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() resolves immediately when called on paused renderer", async () => {
-  renderer.start()
-  renderer.pause()
-
-  await expectIdleToResolveImmediately(renderer)
-})
-
-test("idle() resolves when renderer is destroyed", async () => {
-  renderer.start()
-
-  const idlePromise = renderer.idle()
-
-  renderer.destroy()
-
-  await idlePromise
-})
-
-test("idle() resolves immediately when called on destroyed renderer", async () => {
-  renderer.destroy()
-
-  await expectIdleToResolveImmediately(renderer)
-})
-
-test("idle() waits through multiple requestRender() calls", async () => {
-  renderer.requestRender()
-  renderer.requestRender()
-
-  await renderer.idle()
-
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() works correctly with stop() called during rendering", async () => {
-  renderer.start()
-
-  await new Promise((resolve) => setTimeout(resolve, 50))
-
-  const idlePromise = renderer.idle()
-
-  renderer.stop()
-
-  await idlePromise
-
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() resolves after pause() called during rendering", async () => {
-  renderer.start()
-
-  await new Promise((resolve) => setTimeout(resolve, 50))
-
-  const idlePromise = renderer.idle()
-
-  renderer.pause()
-
-  await idlePromise
-
-  expect(renderer.controlState).toBe(RendererControlState.EXPLICIT_PAUSED)
-  expect(renderer.isRunning).toBe(false)
-})
-
-test("idle() can be used in a loop to wait between operations", async () => {
-  const operations: string[] = []
-
-  operations.push("start")
-  renderer.requestRender()
-  await renderer.idle()
-  operations.push("rendered")
-
-  renderer.requestRender()
-  await renderer.idle()
-  operations.push("rendered again")
-
-  expect(operations).toEqual(["start", "rendered", "rendered again"])
-})
-
-test("idle() works with requestAnimationFrame", async () => {
-  let frameCallbackExecuted = false
-
-  requestAnimationFrame(() => {
-    frameCallbackExecuted = true
-  })
-
-  await renderer.idle()
-
-  expect(frameCallbackExecuted).toBe(true)
-})
-
-test("idle() waits for all animation frames to complete", async () => {
-  let count = 0
-
-  requestAnimationFrame(() => {
-    count++
-    requestAnimationFrame(() => {
-      count++
-    })
-  })
-
-  await renderer.idle()
-
-  expect(count).toBe(2)
-})