@fairyhunter13/opentui-core 0.1.91 → 0.1.94

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

@@ -1,200 +0,0 @@
-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/hover-cursor.test.ts

@@ -1,98 +0,0 @@
-import { beforeEach, describe, expect, test, afterEach } from "bun:test"
-import { createTestRenderer, MouseButtons, type MockMouse, type TestRenderer } from "../testing"
-import { BoxRenderable } from "../renderables"
-import type { MousePointerStyle } from "../types"
-
-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

@@ -1,173 +0,0 @@
-import { test, expect } from "bun:test"
-import { NativeSpanFeed } from "../NativeSpanFeed"
-import { resolveRenderLib } from "../zig"
-
-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

@@ -1,120 +0,0 @@
-import { test, expect } from "bun:test"
-import { NativeSpanFeed } from "../NativeSpanFeed"
-import { resolveRenderLib } from "../zig"
-
-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)
-    }
-  }
-})