@fairyhunter13/opentui-core 0.1.112 → 0.1.114

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

@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, expect, test } from "bun:test"
+import { SystemClock } from "../lib/clock.js"
+import { createTestRenderer, type TestRenderer } from "../testing/test-renderer.js"
+import { ManualClock } from "../testing/manual-clock.js"
+
+let clock: ManualClock
+let renderer: TestRenderer
+let renderOnce: () => Promise<void>
+
+beforeEach(async () => {
+  clock = new ManualClock()
+  ;({ renderer, renderOnce } = await createTestRenderer({ clock, maxFps: 60 }))
+})
+
+afterEach(() => {
+  renderer.destroy()
+})
+
+test("renderer init does not pre-schedule frames when size is unchanged", async () => {
+  let frameCalls = 0
+  renderer.setFrameCallback(async () => {
+    frameCalls++
+  })
+
+  // @ts-expect-error - inspect private renderer scheduling state in regression test
+  expect(renderer.updateScheduled).toBe(false)
+  // @ts-expect-error - inspect private manual clock timers in regression test
+  expect(clock.timers.size).toBe(0)
+
+  clock.advance(100)
+  await Promise.resolve()
+
+  expect(frameCalls).toBe(0)
+})
+
+test("requestRender() does not stall after a backward clock jump", async () => {
+  clock.setTime(10_000)
+  // @ts-expect-error - inspect private renderer timing state in regression test
+  renderer.lastTime = 10_000
+  clock.setTime(8_000)
+
+  let renderCalled = false
+  // @ts-expect-error - intercept private render method in regression test
+  renderer.renderNative = () => {
+    renderCalled = true
+  }
+
+  renderer.requestRender()
+  clock.advance(20)
+  await Promise.resolve()
+
+  expect(renderCalled).toBe(true)
+})
+
+test("requestRender() uses SystemClock by default when no clock is injected", async () => {
+  const originalNow = globalThis.performance.now
+  let nowValue = 10_000
+  let defaultRenderer: TestRenderer | null = null
+
+  globalThis.performance.now = () => nowValue
+
+  try {
+    ;({ renderer: defaultRenderer } = await createTestRenderer({ maxFps: 60 }))
+
+    // @ts-expect-error - inspect private renderer clock in regression test
+    expect(defaultRenderer.clock).toBeInstanceOf(SystemClock)
+
+    // @ts-expect-error - inspect private renderer timing state in regression test
+    defaultRenderer.lastTime = 10_000
+    nowValue = 8_000
+
+    let renderCalled = false
+    // @ts-expect-error - intercept private render method in regression test
+    defaultRenderer.renderNative = () => {
+      renderCalled = true
+    }
+
+    defaultRenderer.requestRender()
+    await Bun.sleep(20)
+
+    expect(renderCalled).toBe(true)
+  } finally {
+    defaultRenderer?.destroy()
+    globalThis.performance.now = originalNow
+  }
+})
+
+test("loop() clamps negative deltaTime after a backward clock jump", async () => {
+  const deltas: number[] = []
+
+  renderer.setFrameCallback(async (deltaTime) => {
+    deltas.push(deltaTime)
+  })
+
+  clock.setTime(10_000)
+  // @ts-expect-error - inspect private renderer timing state in regression test
+  renderer.lastTime = 10_000
+  // @ts-expect-error - inspect private renderer timing state in regression test
+  renderer.lastFpsTime = 10_000
+  clock.setTime(8_000)
+
+  await renderOnce()
+
+  expect(deltas).toEqual([0])
+})
+
+test("targetFps setter updates frame timing", () => {
+  renderer.targetFps = 120
+
+  expect(renderer.targetFps).toBe(120)
+  // @ts-expect-error - inspect private renderer timing state in regression test
+  expect(renderer.targetFrameTime).toBe(1000 / 120)
+})
+
+test("maxFps setter updates requestRender throttle timing", async () => {
+  let renderCalled = false
+
+  // @ts-expect-error - intercept private render method in regression test
+  renderer.renderNative = () => {
+    renderCalled = true
+  }
+
+  renderer.maxFps = 10
+
+  expect(renderer.maxFps).toBe(10)
+  // @ts-expect-error - inspect private renderer timing state in regression test
+  expect(renderer.minTargetFrameTime).toBe(1000 / 10)
+
+  renderer.requestRender()
+
+  clock.advance(99)
+  await Promise.resolve()
+  expect(renderCalled).toBe(false)
+
+  clock.advance(1)
+  await Promise.resolve()
+  expect(renderCalled).toBe(true)
+})
+
+test("start() does not double-schedule frames when a render was already queued", async () => {
+  let renderCalls = 0
+
+  // @ts-expect-error - intercept private render method in regression test
+  renderer.renderNative = () => {
+    renderCalls++
+  }
+
+  renderer.requestRender()
+  renderer.start()
+
+  clock.advance(1000)
+  await Promise.resolve()
+
+  // @ts-expect-error - inspect private manual clock timers in regression test
+  expect(clock.timers.size).toBe(1)
+  expect(renderCalls).toBeGreaterThanOrEqual(25)
+  expect(renderCalls).toBeLessThanOrEqual(40)
+})

package/src/tests/renderer.console-startup.test.ts

@@ -0,0 +1,185 @@
+import { afterEach, beforeEach, expect, test } from "bun:test"
+
+import { capture } from "../console.ts"
+import { clearEnvCache } from "../lib/env.ts"
+import { createTestRenderer, type TestRenderer } from "../testing/test-renderer.js"
+import { ManualClock } from "../testing/manual-clock.js"
+
+let renderer: TestRenderer | null = null
+let previousShowConsole: string | undefined
+let previousUseAlternateScreen: string | undefined
+let previousOverrideStdout: string | undefined
+
+beforeEach(() => {
+  previousShowConsole = process.env.SHOW_CONSOLE
+  previousUseAlternateScreen = process.env.OTUI_USE_ALTERNATE_SCREEN
+  previousOverrideStdout = process.env.OTUI_OVERRIDE_STDOUT
+  delete process.env.SHOW_CONSOLE
+  delete process.env.OTUI_USE_ALTERNATE_SCREEN
+  delete process.env.OTUI_OVERRIDE_STDOUT
+  clearEnvCache()
+})
+
+afterEach(() => {
+  renderer?.destroy()
+  renderer = null
+  capture.claimOutput()
+
+  if (previousShowConsole === undefined) {
+    delete process.env.SHOW_CONSOLE
+  } else {
+    process.env.SHOW_CONSOLE = previousShowConsole
+  }
+
+  if (previousUseAlternateScreen === undefined) {
+    delete process.env.OTUI_USE_ALTERNATE_SCREEN
+  } else {
+    process.env.OTUI_USE_ALTERNATE_SCREEN = previousUseAlternateScreen
+  }
+
+  if (previousOverrideStdout === undefined) {
+    delete process.env.OTUI_OVERRIDE_STDOUT
+  } else {
+    process.env.OTUI_OVERRIDE_STDOUT = previousOverrideStdout
+  }
+
+  clearEnvCache()
+})
+
+test("CliRenderer initializes its clock before SHOW_CONSOLE triggers a render", async () => {
+  process.env.SHOW_CONSOLE = "true"
+  clearEnvCache()
+
+  const result = await createTestRenderer({
+    clock: new ManualClock(),
+  })
+
+  renderer = result.renderer
+
+  expect(renderer).toBeDefined()
+})
+
+test("CliRenderer uses its shared clock for debounced resize", async () => {
+  const clock = new ManualClock()
+  const result = await createTestRenderer({
+    width: 40,
+    height: 20,
+    clock,
+  })
+
+  renderer = result.renderer
+  ;(renderer as any).handleResize(70, 30)
+
+  expect(renderer.width).toBe(40)
+  expect(renderer.height).toBe(20)
+
+  clock.advance(99)
+
+  expect(renderer.width).toBe(40)
+  expect(renderer.height).toBe(20)
+
+  clock.advance(1)
+
+  expect(renderer.width).toBe(70)
+  expect(renderer.height).toBe(30)
+})
+
+test("CliRenderer applies explicit screen and output modes", async () => {
+  const result = await createTestRenderer({
+    screenMode: "split-footer",
+    footerHeight: 6,
+    externalOutputMode: "capture-stdout",
+    consoleMode: "disabled",
+  })
+
+  renderer = result.renderer
+
+  expect(renderer.screenMode).toBe("split-footer")
+  expect(renderer.footerHeight).toBe(6)
+  expect(renderer.externalOutputMode).toBe("capture-stdout")
+  expect(renderer.consoleMode).toBe("disabled")
+})
+
+test("CliRenderer rejects captured output outside split-footer mode", async () => {
+  await expect(
+    createTestRenderer({
+      screenMode: "main-screen",
+      externalOutputMode: "capture-stdout",
+    }),
+  ).rejects.toThrow('externalOutputMode "capture-stdout" requires screenMode "split-footer"')
+})
+
+test("CliRenderer flushes captured output when leaving split-footer for alternate-screen", async () => {
+  const result = await createTestRenderer({
+    screenMode: "split-footer",
+    footerHeight: 6,
+    externalOutputMode: "capture-stdout",
+    consoleMode: "disabled",
+    useThread: false,
+  })
+
+  renderer = result.renderer
+  ;(renderer as any)._terminalIsSetup = true
+  ;(renderer as any).lib.suspendRenderer = () => {}
+  ;(renderer as any).lib.setupTerminal = () => {}
+
+  capture.write("stdout", "pending output\n")
+  renderer.externalOutputMode = "passthrough"
+  renderer.screenMode = "alternate-screen"
+
+  expect(capture.size).toBe(0)
+})
+
+test("CliRenderer allows env to force main-screen mode", async () => {
+  process.env.OTUI_USE_ALTERNATE_SCREEN = "false"
+  clearEnvCache()
+
+  const result = await createTestRenderer({
+    screenMode: "alternate-screen",
+  })
+
+  renderer = result.renderer
+
+  expect(renderer.screenMode).toBe("main-screen")
+})
+
+test("CliRenderer allows env to force alternate-screen mode", async () => {
+  process.env.OTUI_USE_ALTERNATE_SCREEN = "true"
+  clearEnvCache()
+
+  const result = await createTestRenderer({
+    screenMode: "main-screen",
+  })
+
+  renderer = result.renderer
+
+  expect(renderer.screenMode).toBe("alternate-screen")
+})
+
+test("CliRenderer allows env to force passthrough stdout", async () => {
+  process.env.OTUI_OVERRIDE_STDOUT = "false"
+  clearEnvCache()
+
+  const result = await createTestRenderer({
+    screenMode: "split-footer",
+    externalOutputMode: "capture-stdout",
+  })
+
+  renderer = result.renderer
+
+  expect(renderer.externalOutputMode).toBe("passthrough")
+})
+
+test("CliRenderer allows env to force captured stdout in split-footer", async () => {
+  process.env.OTUI_OVERRIDE_STDOUT = "true"
+  clearEnvCache()
+
+  const result = await createTestRenderer({
+    screenMode: "split-footer",
+    externalOutputMode: "passthrough",
+  })
+
+  renderer = result.renderer
+
+  expect(renderer.externalOutputMode).toBe("capture-stdout")
+})