@xincli/opentui-core 0.4.6

package/src/tests/native-span-feed-edge-cases.test.ts

@@ -0,0 +1,384 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+function writeData(stream: NativeSpanFeed, text: string): void {
+  const data = new TextEncoder().encode(text)
+  lib.streamWrite(stream.streamPtr, data)
+}
+
+function commitData(stream: NativeSpanFeed): void {
+  lib.streamCommit(stream.streamPtr)
+}
+
+function produceData(stream: NativeSpanFeed, text: string): void {
+  writeData(stream, text)
+  commitData(stream)
+}
+
+test("throwing handler does not prevent state buffer decrements", () => {
+  // Decrement must happen even if a handler throws.
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: string[] = []
+  let shouldThrow = true
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    if (shouldThrow) {
+      throw new Error("handler error")
+    }
+  })
+
+  try {
+    produceData(stream, "first")
+  } catch {}
+
+  try {
+    produceData(stream, "second")
+  } catch {}
+
+  expect(received).toContain("first")
+  expect(received).toContain("second")
+  shouldThrow = false
+  produceData(stream, "third")
+
+  try {
+    stream.drainAll()
+  } catch {}
+
+  expect(received).toContain("third")
+
+  stream.close()
+})
+
+test("attach with pre-queued data waits for onData", () => {
+  const bootstrap = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+  bootstrap.close()
+  const rawPtr = lib.createNativeSpanFeed({
+    chunkSize: 128,
+    initialChunks: 1,
+    autoCommitOnFull: true,
+  })
+  expect(rawPtr).toBeTruthy()
+
+  const pre = new TextEncoder().encode("pre-attach")
+  lib.streamWrite(rawPtr!, pre)
+  lib.streamCommit(rawPtr!)
+
+  const stream = NativeSpanFeed.attach(rawPtr!)
+
+  const received: string[] = []
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+  })
+
+  stream.drainAll()
+  expect(received).toEqual(["pre-attach"])
+
+  produceData(stream, "post-attach")
+  stream.drainAll()
+  expect(received).toEqual(["pre-attach", "post-attach"])
+
+  stream.close()
+})
+
+test("streamWrite accepts empty JS-owned byte slices", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+  const received: string[] = []
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+  })
+
+  expect(lib.streamWrite(stream.streamPtr, new Uint8Array())).toBe(0)
+  expect(lib.streamWrite(stream.streamPtr, "")).toBe(0)
+  expect(lib.streamCommit(stream.streamPtr)).toBe(0)
+  stream.drainAll()
+  expect(received).toEqual([])
+
+  stream.close()
+})
+
+test("streamWrite rejects null pointers for non-zero writes without trapping", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  const rawStatus = (lib as any).opentui.symbols.streamWrite(stream.streamPtr, null, 1)
+
+  expect(rawStatus).toBe(-3)
+
+  stream.close()
+})
+
+test("decrementRefcount with out-of-bounds chunkIndex does not crash or corrupt", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  const received: string[] = []
+  let closedOnSpan = -1
+
+  stream.onData((data) => {
+    const text = new TextDecoder().decode(data)
+    received.push(text)
+    if (closedOnSpan < 0) {
+      closedOnSpan = 0
+      // Force an empty state buffer to exercise the guard.
+      ;(stream as any).stateBuffer = new Uint8Array(0)
+    }
+  })
+  for (let i = 0; i < 5; i++) {
+    const msg = new TextEncoder().encode(`s${i}`)
+    lib.streamWrite(stream.streamPtr, msg)
+    lib.streamCommit(stream.streamPtr)
+  }
+
+  stream.drainAll()
+  expect(received).toEqual(["s0", "s1", "s2", "s3", "s4"])
+
+  stream.close()
+})
+
+test("toArrayBuffer aliases Zig-owned chunk memory", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: Uint8Array[] = []
+  stream.onData((data) => {
+    received.push(data)
+  })
+
+  produceData(stream, "hello")
+  stream.drainAll()
+
+  expect(received.length).toBe(1)
+  const view = received[0]
+
+  const original = view[0]
+  const sentinel = original ^ 0xff
+  view[0] = sentinel
+  expect(view[0]).toBe(sentinel)
+  // Restore original value so the chunk data isn't corrupted.
+  view[0] = original
+
+  stream.close()
+})
+
+test("state buffer view stays current across chunk growth", () => {
+  // StateBuffer events must keep the TS view in sync after growth.
+  const stream = NativeSpanFeed.create({
+    chunkSize: 32,
+    initialChunks: 1,
+  })
+
+  const allData: string[] = []
+  stream.onData((data) => {
+    allData.push(new TextDecoder().decode(data))
+  })
+
+  for (let i = 0; i < 20; i++) {
+    const msg = new TextEncoder().encode(`msg${i.toString().padStart(2, "0")}`)
+    lib.streamWrite(stream.streamPtr, msg)
+    lib.streamCommit(stream.streamPtr)
+  }
+
+  stream.drainAll()
+
+  const allContent = allData.join("")
+  for (let i = 0; i < 20; i++) {
+    const expected = `msg${i.toString().padStart(2, "0")}`
+    expect(allContent).toContain(expected)
+  }
+  expect(allContent.length).toBe(20 * 5)
+
+  stream.close()
+})
+
+test("state buffer view stays current when writes span multiple chunks", () => {
+  const chunkSize = 32
+  const stream = NativeSpanFeed.create({ chunkSize, initialChunks: 1 })
+
+  const allData: Uint8Array[] = []
+  stream.onData((data) => {
+    allData.push(new Uint8Array(data)) // copy to avoid aliasing
+  })
+
+  const bigWrite = new Uint8Array(256)
+  for (let i = 0; i < 256; i++) bigWrite[i] = i & 0xff
+  lib.streamWrite(stream.streamPtr, bigWrite)
+
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+  const received = new Uint8Array(allData.reduce((sum, d) => sum + d.length, 0))
+  let offset = 0
+  for (const chunk of allData) {
+    received.set(chunk, offset)
+    offset += chunk.length
+  }
+
+  expect(received.length).toBe(256)
+  for (let i = 0; i < 256; i++) {
+    expect(received[i]).toBe(i & 0xff)
+  }
+
+  stream.close()
+})
+
+test("unsubscribing self during onData iteration does not affect other handlers", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+
+  const unsubA = stream.onData(() => {
+    calls.push("A")
+    unsubA()
+  })
+  stream.onData(() => {
+    calls.push("B")
+  })
+
+  produceData(stream, "msg1")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B"])
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B", "B"])
+
+  stream.close()
+})
+
+test("unsubscribing a later handler during iteration skips it", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+  let unsubB: (() => void) | null = null
+
+  stream.onData(() => {
+    calls.push("A")
+    if (unsubB) {
+      unsubB()
+      unsubB = null
+    }
+  })
+
+  unsubB = stream.onData(() => {
+    calls.push("B")
+  })
+
+  produceData(stream, "msg1")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A"])
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "A"])
+
+  stream.close()
+})
+
+test("handler adding a new handler during iteration includes it per Set semantics", () => {
+  // Set iteration visits handlers added before they're reached.
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+
+  let added = false
+  stream.onData(() => {
+    calls.push("A")
+    if (!added) {
+      added = true
+      stream.onData(() => {
+        calls.push("B")
+      })
+    }
+  })
+
+  produceData(stream, "msg1")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B"])
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(calls).toEqual(["A", "B", "A", "B"])
+
+  stream.close()
+})
+
+test("throwing handler does not skip remaining handlers for the same span", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const calls: string[] = []
+
+  stream.onData(() => {
+    calls.push("A")
+    throw new Error("handler A error")
+  })
+  stream.onData((data) => {
+    calls.push("B:" + new TextDecoder().decode(data))
+  })
+
+  let caughtError: unknown
+  try {
+    produceData(stream, "msg1")
+    stream.drainAll()
+  } catch (error) {
+    caughtError = error
+  }
+  expect(caughtError).toBeInstanceOf(Error)
+  expect((caughtError as Error).message).toBe("handler A error")
+  expect(calls).toEqual(["A", "B:msg1"])
+
+  stream.close()
+})
+
+test("reentrant drainAll from handler is safely ignored", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const received: string[] = []
+  let reentrantCallCount = 0
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    reentrantCallCount++
+    stream.drainAll()
+  })
+
+  produceData(stream, "msg1")
+  produceData(stream, "msg2")
+  stream.drainAll()
+
+  expect(received).toContain("msg1")
+  expect(received).toContain("msg2")
+  expect(received.length).toBe(2)
+
+  stream.close()
+})
+
+test("committing during drain does not drop pending spans", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 64, initialChunks: 1 })
+
+  const received: string[] = []
+  let injected = false
+
+  stream.onData((data) => {
+    received.push(new TextDecoder().decode(data))
+    if (!injected) {
+      injected = true
+      const next = new TextEncoder().encode("inner")
+      lib.streamWrite(stream.streamPtr, next)
+      lib.streamCommit(stream.streamPtr)
+    }
+  })
+
+  const first = new TextEncoder().encode("outer")
+  lib.streamWrite(stream.streamPtr, first)
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+
+  expect(received).toEqual(["outer", "inner"])
+
+  stream.close()
+})

package/src/tests/native-span-feed-use-after-free.test.ts

@@ -0,0 +1,45 @@
+import { test, expect } from "bun:test"
+import { NativeSpanFeed } from "../NativeSpanFeed.js"
+import { resolveRenderLib } from "../zig.js"
+
+const lib = resolveRenderLib()
+
+test("close clears chunkMap and internal state", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  const retained: Uint8Array[] = []
+  stream.onData((data) => {
+    retained.push(data)
+  })
+
+  const data = new TextEncoder().encode("hello world")
+  lib.streamWrite(stream.streamPtr, data)
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+
+  expect(retained.length).toBe(1)
+  expect(new TextDecoder().decode(retained[0])).toBe("hello world")
+
+  stream.close()
+  stream.drainAll()
+  expect(retained.length).toBe(1)
+})
+
+test("onData handlers are cleared on close", () => {
+  const stream = NativeSpanFeed.create({ chunkSize: 256, initialChunks: 1 })
+
+  let callCount = 0
+  stream.onData(() => {
+    callCount++
+  })
+
+  const data = new TextEncoder().encode("before close")
+  lib.streamWrite(stream.streamPtr, data)
+  lib.streamCommit(stream.streamPtr)
+  stream.drainAll()
+  expect(callCount).toBe(1)
+
+  stream.close()
+
+  expect(callCount).toBe(1)
+})

package/src/tests/opacity.test.ts

@@ -0,0 +1,123 @@
+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"
+
+class TestRenderable extends Renderable {
+  constructor(ctx: RenderContext, options: RenderableOptions) {
+    super(ctx, options)
+  }
+}
+
+let testRenderer: TestRenderer
+let renderOnce: () => Promise<void>
+
+beforeEach(async () => {
+  ;({ renderer: testRenderer, renderOnce } = await createTestRenderer({}))
+})
+
+afterEach(() => {
+  testRenderer.destroy()
+})
+
+describe("Renderable - Opacity", () => {
+  test("defaults to 1.0", () => {
+    const renderable = new TestRenderable(testRenderer, { id: "test-opacity" })
+    expect(renderable.opacity).toBe(1.0)
+  })
+
+  test("accepts opacity in constructor options", () => {
+    const renderable = new TestRenderable(testRenderer, {
+      id: "test-opacity-options",
+      opacity: 0.5,
+    })
+    expect(renderable.opacity).toBe(0.5)
+  })
+
+  test("clamps opacity to 0-1 range via setter", () => {
+    const renderable = new TestRenderable(testRenderer, { id: "test-clamp" })
+
+    renderable.opacity = 1.5
+    expect(renderable.opacity).toBe(1.0)
+
+    renderable.opacity = -0.5
+    expect(renderable.opacity).toBe(0.0)
+
+    renderable.opacity = 0.7
+    expect(renderable.opacity).toBe(0.7)
+  })
+
+  test("clamps opacity from constructor options", () => {
+    const r1 = new TestRenderable(testRenderer, {
+      id: "test-clamp-high",
+      opacity: 2.0,
+    })
+    expect(r1.opacity).toBe(1.0)
+
+    const r2 = new TestRenderable(testRenderer, {
+      id: "test-clamp-low",
+      opacity: -1,
+    })
+    expect(r2.opacity).toBe(0.0)
+  })
+
+  test("handles opacity of 0 (fully transparent)", async () => {
+    const renderable = new TestRenderable(testRenderer, {
+      id: "invisible",
+      width: 10,
+      height: 5,
+      opacity: 0,
+    })
+    testRenderer.root.add(renderable)
+
+    expect(renderable.opacity).toBe(0)
+
+    // Render should not crash with zero opacity
+    await renderOnce()
+  })
+
+  test("nested renderables maintain independent opacity values", async () => {
+    const parent = new TestRenderable(testRenderer, {
+      id: "parent",
+      width: 20,
+      height: 10,
+      opacity: 0.5,
+    })
+
+    const child = new TestRenderable(testRenderer, {
+      id: "child",
+      width: 10,
+      height: 5,
+      opacity: 0.8,
+    })
+
+    parent.add(child)
+    testRenderer.root.add(parent)
+    await renderOnce()
+
+    expect(parent.opacity).toBe(0.5)
+    expect(child.opacity).toBe(0.8)
+  })
+
+  test("opacity changes trigger render request", () => {
+    const renderable = new TestRenderable(testRenderer, { id: "test-render" })
+    testRenderer.root.add(renderable)
+
+    const initialOpacity = renderable.opacity
+    renderable.opacity = 0.3
+
+    expect(renderable.opacity).not.toBe(initialOpacity)
+    expect(renderable.opacity).toBe(0.3)
+  })
+
+  test("setting same opacity value does not update", () => {
+    const renderable = new TestRenderable(testRenderer, {
+      id: "test-same",
+      opacity: 0.5,
+    })
+
+    // Set to same value - should not trigger change
+    renderable.opacity = 0.5
+    expect(renderable.opacity).toBe(0.5)
+  })
+})