@fairyhunter13/opentui-core 0.1.112 → 0.1.114

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

@@ -0,0 +1,200 @@
+import { test, expect, beforeEach, afterEach, describe } from "bun:test"
+import { Renderable, type RenderableOptions } from "../Renderable.js"
+import { createTestRenderer, type TestRenderer } from "../testing/test-renderer.js"
+import type { RenderContext } from "../types.js"
+import type { OptimizedBuffer } from "../buffer.js"
+
+class TestRenderable extends Renderable {
+  public renderSelfCalled = false
+  public customOnUpdate?: () => void
+
+  constructor(ctx: RenderContext, options: RenderableOptions) {
+    super(ctx, options)
+  }
+
+  public override onUpdate(deltaTime: number): void {
+    if (this.customOnUpdate) {
+      this.customOnUpdate()
+    }
+  }
+
+  protected override renderSelf(buffer: OptimizedBuffer, deltaTime: number): void {
+    this.renderSelfCalled = true
+  }
+}
+
+let testRenderer: TestRenderer
+let renderOnce: () => Promise<void>
+
+beforeEach(async () => {
+  ;({ renderer: testRenderer, renderOnce } = await createTestRenderer({}))
+})
+
+afterEach(() => {
+  testRenderer.destroy()
+})
+
+describe("Destroy During Render - Actual Bugs", () => {
+  test("BUG: destroying self in onUpdate still calls renderSelf", async () => {
+    const renderable = new TestRenderable(testRenderer, {
+      id: "test",
+      width: 100,
+      height: 100,
+    })
+
+    renderable.customOnUpdate = () => {
+      renderable.destroy()
+    }
+
+    testRenderer.root.add(renderable)
+    await renderOnce()
+
+    expect(renderable.isDestroyed).toBe(true)
+    // BUG: renderSelf should NOT be called after destroy in onUpdate
+    expect(renderable.renderSelfCalled).toBe(false)
+  })
+
+  test("BUG: destroying child in parent's onUpdate, child still renders", async () => {
+    const parent = new TestRenderable(testRenderer, {
+      id: "parent",
+      width: 100,
+      height: 100,
+    })
+    const child = new TestRenderable(testRenderer, {
+      id: "child",
+      width: 50,
+      height: 50,
+    })
+
+    parent.add(child)
+    testRenderer.root.add(parent)
+
+    parent.customOnUpdate = () => {
+      child.destroy()
+    }
+
+    await renderOnce()
+
+    expect(child.isDestroyed).toBe(true)
+    // BUG: Child should not render if destroyed in parent's onUpdate
+    expect(child.renderSelfCalled).toBe(false)
+  })
+
+  test("BUG: destroying sibling in onUpdate, sibling still renders", async () => {
+    const parent = new TestRenderable(testRenderer, { id: "parent" })
+    const child1 = new TestRenderable(testRenderer, {
+      id: "child1",
+      width: 50,
+      height: 50,
+    })
+    const child2 = new TestRenderable(testRenderer, {
+      id: "child2",
+      width: 50,
+      height: 50,
+    })
+
+    parent.add(child1)
+    parent.add(child2)
+    testRenderer.root.add(parent)
+
+    child1.customOnUpdate = () => {
+      child2.destroy()
+    }
+
+    await renderOnce()
+
+    expect(child2.isDestroyed).toBe(true)
+    // BUG: child2 should not render if destroyed by sibling's onUpdate
+    expect(child2.renderSelfCalled).toBe(false)
+  })
+
+  test("BUG: destroying sibling in renderBefore, sibling (later in render list) still renders", async () => {
+    const parent = new TestRenderable(testRenderer, { id: "parent" })
+    const child2 = new TestRenderable(testRenderer, {
+      id: "child2",
+      width: 50,
+      height: 50,
+      zIndex: 2,
+    })
+
+    const child1 = new TestRenderable(testRenderer, {
+      id: "child1",
+      width: 50,
+      height: 50,
+      zIndex: 1,
+      renderBefore: function () {
+        child2.destroy()
+      },
+    })
+
+    parent.add(child1)
+    parent.add(child2)
+    testRenderer.root.add(parent)
+
+    await renderOnce()
+
+    expect(child2.isDestroyed).toBe(true)
+    // BUG: child2 should not render since it was destroyed before its turn
+    expect(child2.renderSelfCalled).toBe(false)
+  })
+
+  test("BUG: onLifecyclePass not called (registration issue)", async () => {
+    let lifecyclePassCalled = false
+
+    const renderable = new TestRenderable(testRenderer, { id: "test" })
+    renderable.onLifecyclePass = () => {
+      lifecyclePassCalled = true
+    }
+
+    testRenderer.root.add(renderable)
+    await renderOnce()
+
+    // BUG: Lifecycle pass should be called but isn't
+    expect(lifecyclePassCalled).toBe(true)
+  })
+})
+
+describe("Destroy During Render - Working Cases (for documentation)", () => {
+  test("WORKS: destroying self in renderAfter", async () => {
+    const renderable = new TestRenderable(testRenderer, {
+      id: "test",
+      width: 100,
+      height: 100,
+      renderAfter: function () {
+        this.destroy()
+      },
+    })
+
+    testRenderer.root.add(renderable)
+    await renderOnce()
+
+    expect(renderable.isDestroyed).toBe(true)
+    // renderSelf was already called by this point, which is fine
+    expect(renderable.renderSelfCalled).toBe(true)
+  })
+
+  test("WORKS: destroying child in renderAfter", async () => {
+    const child = new TestRenderable(testRenderer, {
+      id: "child",
+      width: 50,
+      height: 50,
+    })
+
+    const parent = new TestRenderable(testRenderer, {
+      id: "parent",
+      width: 100,
+      height: 100,
+      renderAfter: function () {
+        child.destroy()
+      },
+    })
+
+    parent.add(child)
+    testRenderer.root.add(parent)
+
+    await renderOnce()
+
+    expect(child.isDestroyed).toBe(true)
+    // Child already rendered before parent's renderAfter, which is expected
+  })
+})

package/src/tests/destroy-on-exit.fixture.ts

@@ -0,0 +1,36 @@
+import { Readable } from "node:stream"
+import { createTestRenderer } from "@opentui/core/testing"
+
+const code = parseInt(process.argv[2] ?? "0", 10)
+const mode = process.argv[3] ?? "idle"
+
+const stdin = new Readable({ read() {} }) as NodeJS.ReadStream & {
+  setRawMode: (enabled: boolean) => NodeJS.ReadStream
+}
+stdin.setRawMode = (enabled) => {
+  if (!enabled) {
+    console.log("raw mode disabled")
+  }
+  return stdin
+}
+
+const { renderer } = await createTestRenderer({ width: 20, height: 10, stdin })
+const lib = (renderer as any).lib
+const originalSuspendRenderer = lib.suspendRenderer.bind(lib)
+lib.suspendRenderer = (rendererPtr: unknown) => {
+  console.log("renderer suspended")
+  originalSuspendRenderer(rendererPtr)
+}
+
+process.on("exit", () => {
+  renderer.destroy()
+})
+
+if (mode === "during-render") {
+  renderer.setFrameCallback(async () => {
+    process.exit(code)
+  })
+  renderer.start()
+} else {
+  process.exit(code)
+}

package/src/tests/destroy-on-exit.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "bun:test"
+import { join } from "node:path"
+
+const fixturePath = join(import.meta.dir, "destroy-on-exit.fixture.ts")
+
+const runFixture = (code: number, mode: "idle" | "during-render" = "idle") => {
+  const result = Bun.spawnSync([process.execPath, fixturePath, code.toString(), mode], {
+    cwd: join(import.meta.dir, ".."),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  })
+
+  const stdout = result.stdout.toString()
+
+  return { result, stdout }
+}
+
+describe("destroy on process exit", () => {
+  it("it should let applications restore terminal state in an exit handler", () => {
+    const { result, stdout } = runFixture(0)
+
+    expect(result.exitCode).toBe(0)
+    expect(stdout).toInclude("raw mode disabled")
+  })
+
+  it("it should restore terminal state for non-zero exit codes", () => {
+    const { result, stdout } = runFixture(1)
+
+    expect(result.exitCode).toBe(1)
+    expect(stdout).toInclude("raw mode disabled")
+  })
+
+  it("it should suspend the renderer when destroy happens during an active frame in an exit handler", () => {
+    const { result, stdout } = runFixture(0, "during-render")
+
+    expect(result.exitCode).toBe(0)
+    expect(stdout).toInclude("raw mode disabled")
+    expect(stdout).toInclude("renderer suspended")
+  })
+})

package/src/tests/hover-cursor.test.ts

@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, test, afterEach } from "bun:test"
+import { createTestRenderer, MouseButtons, type MockMouse, type TestRenderer } from "../testing.js"
+import { BoxRenderable } from "../renderables/index.js"
+import type { MousePointerStyle } from "../types.js"
+
+describe("mouse pointer style", () => {
+  let renderer: TestRenderer
+  let mockMouse: MockMouse
+  let renderOnce: () => Promise<void>
+
+  beforeEach(async () => {
+    ;({ renderer, mockMouse, renderOnce } = await createTestRenderer({ width: 40, height: 20 }))
+  })
+
+  afterEach(() => {
+    renderer.destroy()
+  })
+
+  test("setMousePointer sets style", async () => {
+    renderer.setMousePointer("pointer")
+    expect((renderer as any)._currentMousePointerStyle).toBe("pointer")
+  })
+
+  test("setMousePointer with 'default' clears style", async () => {
+    renderer.setMousePointer("pointer")
+    renderer.setMousePointer("default")
+    expect((renderer as any)._currentMousePointerStyle).toBe("default")
+  })
+
+  test("setMousePointer supports all style types", async () => {
+    const styles: MousePointerStyle[] = ["default", "pointer", "text", "crosshair", "move", "not-allowed"]
+    for (const style of styles) {
+      renderer.setMousePointer(style)
+      expect((renderer as any)._currentMousePointerStyle).toBe(style)
+    }
+  })
+
+  test("onMouseOver callback can set mouse pointer", async () => {
+    let pointerSet = false
+    const box = new BoxRenderable(renderer, {
+      position: "absolute",
+      left: 5,
+      top: 5,
+      width: 10,
+      height: 5,
+      onMouseOver() {
+        this.ctx.setMousePointer("pointer")
+        pointerSet = true
+      },
+    })
+    renderer.root.add(box)
+    await renderOnce()
+
+    await mockMouse.moveTo(10, 7)
+    await renderOnce()
+
+    expect(pointerSet).toBe(true)
+    expect((renderer as any)._currentMousePointerStyle).toBe("pointer")
+  })
+
+  test("onMouseOut callback can reset mouse pointer", async () => {
+    let pointerReset = false
+    const box = new BoxRenderable(renderer, {
+      position: "absolute",
+      left: 5,
+      top: 5,
+      width: 10,
+      height: 5,
+      onMouseOver() {
+        this.ctx.setMousePointer("pointer")
+      },
+      onMouseOut() {
+        this.ctx.setMousePointer("default")
+        pointerReset = true
+      },
+    })
+    renderer.root.add(box)
+    await renderOnce()
+
+    // Move into box
+    await mockMouse.moveTo(10, 7)
+    await renderOnce()
+    expect((renderer as any)._currentMousePointerStyle).toBe("pointer")
+
+    // Move out of box
+    await mockMouse.moveTo(1, 1)
+    await renderOnce()
+
+    expect(pointerReset).toBe(true)
+    expect((renderer as any)._currentMousePointerStyle).toBe("default")
+  })
+
+  test("pointer resets on renderer destroy", async () => {
+    renderer.setMousePointer("pointer")
+    renderer.destroy()
+    // After destroy, the reset is called internally - just verify no error
+  })
+})

package/src/tests/native-span-feed-async.test.ts

@@ -0,0 +1,173 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+function writeAndCommit(stream: NativeSpanFeed, data: Uint8Array): void {
+  lib.streamWrite(stream.streamPtr, data)
+  lib.streamCommit(stream.streamPtr)
+}
+
+test("async handler keeps chunk pinned until Promise resolves", async () => {
+  // Single chunk forces reuse; async handlers must keep data pinned.
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  let resolveHandler!: () => void
+  const handlerDone = new Promise<void>((r) => {
+    resolveHandler = r
+  })
+
+  let capturedData: Uint8Array | null = null
+  let dataValidAtResolve = false
+
+  stream.onData(async (data) => {
+    capturedData = data
+    const originalBytes = new Uint8Array(data)
+    await handlerDone
+    dataValidAtResolve = capturedData.every((b, i) => b === originalBytes[i])
+  })
+  const original = new Uint8Array(64)
+  for (let i = 0; i < 64; i++) original[i] = i
+  writeAndCommit(stream, original)
+  const overwrite = new Uint8Array(64).fill(0xff)
+  writeAndCommit(stream, overwrite)
+  stream.drainAll()
+  resolveHandler()
+  await new Promise((r) => setTimeout(r, 10))
+
+  expect(capturedData).not.toBeNull()
+  expect(dataValidAtResolve).toBe(true)
+
+  stream.close()
+})
+
+test("mixed sync and async handlers on same stream", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const syncReceived: string[] = []
+  let asyncReceived: string[] = []
+  let resolveAsync!: () => void
+  const asyncDone = new Promise<void>((r) => {
+    resolveAsync = r
+  })
+
+  stream.onData((data) => {
+    syncReceived.push(new TextDecoder().decode(data))
+  })
+  stream.onData(async (data) => {
+    const text = new TextDecoder().decode(data)
+    await asyncDone
+    asyncReceived.push(text)
+  })
+
+  const msg = new TextEncoder().encode("hello")
+  writeAndCommit(stream, msg)
+  stream.drainAll()
+
+  expect(syncReceived).toEqual(["hello"])
+  expect(asyncReceived).toEqual([])
+  resolveAsync()
+  await new Promise((r) => setTimeout(r, 10))
+
+  expect(asyncReceived).toEqual(["hello"])
+
+  stream.close()
+})
+
+test("async handler rejection still decrements refcount", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  stream.onData(async () => {
+    throw new Error("async failure")
+  })
+
+  const data = new Uint8Array(64).fill(0xaa)
+  writeAndCommit(stream, data)
+  stream.drainAll()
+
+  await new Promise((r) => setTimeout(r, 10))
+  const received: Uint8Array[] = []
+  stream.onData((d) => {
+    received.push(new Uint8Array(d))
+  })
+
+  const data2 = new Uint8Array(64).fill(0xbb)
+  writeAndCommit(stream, data2)
+  stream.drainAll()
+
+  expect(received.length).toBe(1)
+  expect(received[0][0]).toBe(0xbb)
+
+  stream.close()
+})
+
+test("sync-only handlers decrement refcount immediately (no regression)", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  const received: string[] = []
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+  })
+
+  const msg1 = new TextEncoder().encode("A".repeat(64))
+  writeAndCommit(stream, msg1)
+  stream.drainAll()
+  const msg2 = new TextEncoder().encode("B".repeat(64))
+  writeAndCommit(stream, msg2)
+  stream.drainAll()
+
+  expect(received.length).toBe(2)
+  expect(received[1]).toBe("B".repeat(64))
+
+  stream.close()
+})
+
+test("multiple async handlers all settle before refcount decrement", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  let resolve1!: () => void
+  let resolve2!: () => void
+  const done1 = new Promise<void>((r) => {
+    resolve1 = r
+  })
+  const done2 = new Promise<void>((r) => {
+    resolve2 = r
+  })
+
+  const order: string[] = []
+
+  stream.onData(async (_data) => {
+    await done1
+    order.push("handler1")
+  })
+
+  stream.onData(async (_data) => {
+    await done2
+    order.push("handler2")
+  })
+
+  const data = new Uint8Array(64).fill(0xcc)
+  writeAndCommit(stream, data)
+  stream.drainAll()
+
+  resolve1()
+  await new Promise((r) => setTimeout(r, 10))
+  resolve2()
+  await new Promise((r) => setTimeout(r, 10))
+
+  expect(order).toEqual(["handler1", "handler2"])
+
+  const received: number[] = []
+  stream.onData((d) => {
+    received.push(d[0])
+  })
+
+  const data2 = new Uint8Array(64).fill(0xdd)
+  writeAndCommit(stream, data2)
+  stream.drainAll()
+
+  expect(received).toContain(0xdd)
+
+  stream.close()
+})

package/src/tests/native-span-feed-close.test.ts

@@ -0,0 +1,120 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+function nextTick(): Promise<void> {
+  // Use a timer turn instead of process.nextTick so Promise/microtask work
+  // from async handlers and close deferral can settle before assertions.
+  return new Promise((resolve) => setTimeout(resolve, 0))
+}
+
+const enum EventId {
+  Closed = 5,
+}
+
+test("streamClose emits Closed once", () => {
+  const events: number[] = []
+
+  const streamPtr = lib.createNativeSpanFeed(null)
+  expect(streamPtr).not.toBe(0)
+  expect(streamPtr).not.toBeNull()
+  lib.registerNativeSpanFeedStream(streamPtr!, (eventId) => {
+    events.push(Number(eventId))
+  })
+  expect(lib.attachNativeSpanFeed(streamPtr!)).toBe(0)
+
+  expect(lib.streamClose(streamPtr!)).toBe(0)
+  expect(lib.streamClose(streamPtr!)).toBe(0)
+  lib.unregisterNativeSpanFeedStream(streamPtr!)
+  lib.destroyNativeSpanFeed(streamPtr!)
+
+  const closedEvents = events.filter((id) => id === EventId.Closed).length
+  expect(closedEvents).toBe(1)
+})
+
+test("destroyNativeSpanFeed emits Closed when needed", () => {
+  const events: number[] = []
+
+  const streamPtr = lib.createNativeSpanFeed(null)
+  expect(streamPtr).not.toBe(0)
+  expect(streamPtr).not.toBeNull()
+  lib.registerNativeSpanFeedStream(streamPtr!, (eventId) => {
+    events.push(Number(eventId))
+  })
+  expect(lib.attachNativeSpanFeed(streamPtr!)).toBe(0)
+  lib.destroyNativeSpanFeed(streamPtr!)
+
+  const closedEvents = events.filter((id) => id === EventId.Closed).length
+  expect(closedEvents).toBe(1)
+})
+
+test("close should not destroy immediately while async handler is still pending", async () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+  const ptr = stream.streamPtr
+
+  let release!: () => void
+  const gate = new Promise<void>((resolve) => {
+    release = resolve
+  })
+
+  let handlerStarted = false
+  let handlerSettled = false
+
+  stream.onData(async (_data) => {
+    handlerStarted = true
+    await gate
+    handlerSettled = true
+  })
+
+  const payload = new Uint8Array(64).fill(0xaa)
+  lib.streamWrite(ptr, payload)
+  lib.streamCommit(ptr)
+  stream.drainAll()
+
+  expect(handlerStarted).toBe(true)
+
+  stream.close()
+
+  const destroyedImmediately = (stream as any).destroyed === true
+
+  release()
+  await nextTick()
+
+  expect(handlerSettled).toBe(true)
+
+  try {
+    expect(destroyedImmediately).toBe(false)
+  } finally {
+    if (!(stream as any).destroyed) {
+      lib.destroyNativeSpanFeed(ptr)
+    }
+  }
+})
+
+test("close should not destroy when native close reports Busy", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1, autoCommitOnFull: false })
+  const ptr = stream.streamPtr
+
+  const reserve = lib.streamReserve(ptr, 1)
+  expect(reserve.status).toBe(0)
+
+  try {
+    stream.close()
+  } catch {
+    // If close starts throwing on Busy, that's acceptable for this assertion.
+  }
+
+  const destroyedAfterBusyClose = (stream as any).destroyed === true
+
+  try {
+    expect(destroyedAfterBusyClose).toBe(false)
+  } finally {
+    if (!(stream as any).destroyed) {
+      lib.streamCommitReserved(ptr, 0)
+      lib.streamClose(ptr)
+      lib.destroyNativeSpanFeed(ptr)
+    }
+  }
+})