@xincli/opentui-core 0.4.6

package/src/lib/yoga.options.ts

@@ -0,0 +1,346 @@
+import {
+  BoxSizing,
+  Align,
+  Dimension,
+  Direction,
+  Display,
+  Edge,
+  FlexDirection,
+  Gutter,
+  Justify,
+  LogLevel,
+  MeasureMode,
+  Overflow,
+  PositionType,
+  Unit,
+  Wrap,
+} from "../yoga.js"
+
+export type AlignString =
+  | "auto"
+  | "flex-start"
+  | "center"
+  | "flex-end"
+  | "stretch"
+  | "baseline"
+  | "space-between"
+  | "space-around"
+  | "space-evenly"
+export type BoxSizingString = "border-box" | "content-box"
+export type DimensionString = "width" | "height"
+export type DirectionString = "inherit" | "ltr" | "rtl"
+export type DisplayString = "flex" | "none" | "contents"
+export type EdgeString = "left" | "top" | "right" | "bottom" | "start" | "end" | "horizontal" | "vertical" | "all"
+export type FlexDirectionString = "column" | "column-reverse" | "row" | "row-reverse"
+export type GutterString = "column" | "row" | "all"
+export type JustifyString = "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | "space-evenly"
+export type LogLevelString = "error" | "warn" | "info" | "debug" | "verbose" | "fatal"
+export type MeasureModeString = "undefined" | "exactly" | "at-most"
+export type OverflowString = "visible" | "hidden" | "scroll"
+export type PositionTypeString = "static" | "relative" | "absolute"
+export type UnitString = "undefined" | "point" | "percent" | "auto"
+export type WrapString = "no-wrap" | "wrap" | "wrap-reverse"
+
+export function parseAlign(value: string | null | undefined): Align {
+  if (value == null) {
+    return Align.Auto
+  }
+  switch (value.toLowerCase()) {
+    case "auto":
+      return Align.Auto
+    case "flex-start":
+      return Align.FlexStart
+    case "center":
+      return Align.Center
+    case "flex-end":
+      return Align.FlexEnd
+    case "stretch":
+      return Align.Stretch
+    case "baseline":
+      return Align.Baseline
+    case "space-between":
+      return Align.SpaceBetween
+    case "space-around":
+      return Align.SpaceAround
+    case "space-evenly":
+      return Align.SpaceEvenly
+    default:
+      return Align.Auto
+  }
+}
+
+export function parseAlignItems(value: string | null | undefined): Align {
+  if (value == null) {
+    return Align.Stretch
+  }
+  switch (value.toLowerCase()) {
+    case "auto":
+      return Align.Auto
+    case "flex-start":
+      return Align.FlexStart
+    case "center":
+      return Align.Center
+    case "flex-end":
+      return Align.FlexEnd
+    case "stretch":
+      return Align.Stretch
+    case "baseline":
+      return Align.Baseline
+    case "space-between":
+      return Align.SpaceBetween
+    case "space-around":
+      return Align.SpaceAround
+    case "space-evenly":
+      return Align.SpaceEvenly
+    default:
+      return Align.Stretch
+  }
+}
+
+export function parseBoxSizing(value: string): BoxSizing {
+  if (value == null) {
+    return BoxSizing.BorderBox
+  }
+  switch (value.toLowerCase()) {
+    case "border-box":
+      return BoxSizing.BorderBox
+    case "content-box":
+      return BoxSizing.ContentBox
+    default:
+      return BoxSizing.BorderBox
+  }
+}
+
+export function parseDimension(value: string): Dimension {
+  if (value == null) {
+    return Dimension.Width
+  }
+  switch (value.toLowerCase()) {
+    case "width":
+      return Dimension.Width
+    case "height":
+      return Dimension.Height
+    default:
+      return Dimension.Width
+  }
+}
+
+export function parseDirection(value: string): Direction {
+  if (value == null) {
+    return Direction.LTR
+  }
+  switch (value.toLowerCase()) {
+    case "inherit":
+      return Direction.Inherit
+    case "ltr":
+      return Direction.LTR
+    case "rtl":
+      return Direction.RTL
+    default:
+      return Direction.LTR
+  }
+}
+
+export function parseDisplay(value: string): Display {
+  if (value == null) {
+    return Display.Flex
+  }
+  switch (value.toLowerCase()) {
+    case "flex":
+      return Display.Flex
+    case "none":
+      return Display.None
+    case "contents":
+      return Display.Contents
+    default:
+      return Display.Flex
+  }
+}
+
+export function parseEdge(value: string): Edge {
+  if (value == null) {
+    return Edge.All
+  }
+  switch (value.toLowerCase()) {
+    case "left":
+      return Edge.Left
+    case "top":
+      return Edge.Top
+    case "right":
+      return Edge.Right
+    case "bottom":
+      return Edge.Bottom
+    case "start":
+      return Edge.Start
+    case "end":
+      return Edge.End
+    case "horizontal":
+      return Edge.Horizontal
+    case "vertical":
+      return Edge.Vertical
+    case "all":
+      return Edge.All
+    default:
+      return Edge.All
+  }
+}
+
+export function parseFlexDirection(value: string | null | undefined): FlexDirection {
+  if (value == null) {
+    return FlexDirection.Column
+  }
+  switch (value.toLowerCase()) {
+    case "column":
+      return FlexDirection.Column
+    case "column-reverse":
+      return FlexDirection.ColumnReverse
+    case "row":
+      return FlexDirection.Row
+    case "row-reverse":
+      return FlexDirection.RowReverse
+    default:
+      return FlexDirection.Column
+  }
+}
+
+export function parseGutter(value: string): Gutter {
+  if (value == null) {
+    return Gutter.All
+  }
+  switch (value.toLowerCase()) {
+    case "column":
+      return Gutter.Column
+    case "row":
+      return Gutter.Row
+    case "all":
+      return Gutter.All
+    default:
+      return Gutter.All
+  }
+}
+
+export function parseJustify(value: string | null | undefined): Justify {
+  if (value == null) {
+    return Justify.FlexStart
+  }
+  switch (value.toLowerCase()) {
+    case "flex-start":
+      return Justify.FlexStart
+    case "center":
+      return Justify.Center
+    case "flex-end":
+      return Justify.FlexEnd
+    case "space-between":
+      return Justify.SpaceBetween
+    case "space-around":
+      return Justify.SpaceAround
+    case "space-evenly":
+      return Justify.SpaceEvenly
+    default:
+      return Justify.FlexStart
+  }
+}
+
+export function parseLogLevel(value: string): LogLevel {
+  if (value == null) {
+    return LogLevel.Info
+  }
+  switch (value.toLowerCase()) {
+    case "error":
+      return LogLevel.Error
+    case "warn":
+      return LogLevel.Warn
+    case "info":
+      return LogLevel.Info
+    case "debug":
+      return LogLevel.Debug
+    case "verbose":
+      return LogLevel.Verbose
+    case "fatal":
+      return LogLevel.Fatal
+    default:
+      return LogLevel.Info
+  }
+}
+
+export function parseMeasureMode(value: string): MeasureMode {
+  if (value == null) {
+    return MeasureMode.Undefined
+  }
+  switch (value.toLowerCase()) {
+    case "undefined":
+      return MeasureMode.Undefined
+    case "exactly":
+      return MeasureMode.Exactly
+    case "at-most":
+      return MeasureMode.AtMost
+    default:
+      return MeasureMode.Undefined
+  }
+}
+
+export function parseOverflow(value: string | null | undefined): Overflow {
+  if (value == null) {
+    return Overflow.Visible
+  }
+  switch (value.toLowerCase()) {
+    case "visible":
+      return Overflow.Visible
+    case "hidden":
+      return Overflow.Hidden
+    case "scroll":
+      return Overflow.Scroll
+    default:
+      return Overflow.Visible
+  }
+}
+
+export function parsePositionType(value: string | null | undefined): PositionType {
+  if (value == null) {
+    return PositionType.Relative
+  }
+  switch (value.toLowerCase()) {
+    case "static":
+      return PositionType.Static
+    case "relative":
+      return PositionType.Relative
+    case "absolute":
+      return PositionType.Absolute
+    default:
+      return PositionType.Static
+  }
+}
+
+export function parseUnit(value: string): Unit {
+  if (value == null) {
+    return Unit.Point
+  }
+  switch (value.toLowerCase()) {
+    case "undefined":
+      return Unit.Undefined
+    case "point":
+      return Unit.Point
+    case "percent":
+      return Unit.Percent
+    case "auto":
+      return Unit.Auto
+    default:
+      return Unit.Point
+  }
+}
+
+export function parseWrap(value: string | null | undefined): Wrap {
+  if (value == null) {
+    return Wrap.NoWrap
+  }
+  switch (value.toLowerCase()) {
+    case "no-wrap":
+      return Wrap.NoWrap
+    case "wrap":
+      return Wrap.Wrap
+    case "wrap-reverse":
+      return Wrap.WrapReverse
+    default:
+      return Wrap.NoWrap
+  }
+}

package/src/native-event-worker-repro.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test"
+import { EditBuffer } from "./edit-buffer.js"
+
+function waitForWorker(worker: Worker) {
+  let timeout: ReturnType<typeof setTimeout> | undefined
+  return new Promise<void>((resolve, reject) => {
+    timeout = setTimeout(() => reject(new Error("worker did not complete")), 5_000)
+    worker.addEventListener("message", () => resolve(), { once: true })
+    worker.addEventListener(
+      "error",
+      (event) => {
+        reject(event.error ?? new Error(event.message))
+      },
+      { once: true },
+    )
+  }).finally(() => {
+    if (timeout) clearTimeout(timeout)
+  })
+}
+
+describe("native event worker callback repro", () => {
+  test("keeps native event callback valid after a worker installs and releases its callback", async () => {
+    const first = EditBuffer.create("unicode")
+    first.on("content-changed", () => {})
+    first.setText("main-before-worker")
+    await Bun.sleep(0)
+
+    const worker = new Worker(new URL("./native-event-worker-repro.worker.ts", import.meta.url), {
+      type: "module",
+    })
+    await waitForWorker(worker)
+    await worker.terminate()
+
+    let delivered = 0
+    const second = EditBuffer.create("unicode")
+    second.on("content-changed", () => {
+      delivered++
+    })
+
+    second.setText("main-after-worker")
+    await Bun.sleep(0)
+
+    second.destroy()
+    first.destroy()
+
+    expect(delivered).toBe(1)
+  })
+})

package/src/native-event-worker-repro.worker.ts

@@ -0,0 +1,9 @@
+import { EditBuffer } from "./edit-buffer.js"
+
+const buffer = EditBuffer.create("unicode")
+buffer.on("content-changed", () => {})
+buffer.setText("worker")
+await Bun.sleep(0)
+buffer.destroy()
+
+self.postMessage("done")

package/src/native-handle.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, test } from "bun:test"
+import { OptimizedBuffer } from "./buffer.js"
+import { RGBA } from "./lib/RGBA.js"
+import { TextBuffer } from "./text-buffer.js"
+import { TextBufferView } from "./text-buffer-view.js"
+import { EditBuffer } from "./edit-buffer.js"
+import { EditorView } from "./editor-view.js"
+import { SyntaxStyle } from "./syntax-style.js"
+import type { Pointer } from "./platform/ffi.js"
+import Yoga from "./yoga.js"
+import {
+  NativeMeasureTargetKind,
+  resolveRenderLib,
+  setRenderLibPath,
+  type OptimizedBufferHandle,
+  type RendererHandle,
+  type TextBufferHandle,
+} from "./zig.js"
+
+describe("native handles", () => {
+  test("render library path cannot change after native use", () => {
+    resolveRenderLib()
+    expect(() => setRenderLibPath("/tmp/opentui-unused-native-library.so")).toThrow(
+      "setRenderLibPath() must be called before resolveRenderLib()",
+    )
+  })
+
+  test("renderer calls after destroy are rejected safely", () => {
+    const lib = resolveRenderLib()
+    const renderer = lib.createRenderer(4, 3, { bufferedOutput: "memory" })
+    expect(renderer).toBeTruthy()
+    const rendererHandle = renderer as RendererHandle
+    const current = lib.getCurrentBuffer(rendererHandle)
+    const currentHandle = current.ptr
+
+    lib.destroyRenderer(rendererHandle)
+    lib.setCursorPosition(rendererHandle, 1, 1, true)
+    lib.destroyRenderer(rendererHandle)
+
+    expect(lib.getBufferWidth(currentHandle)).toBe(0)
+
+    const second = lib.createRenderer(4, 3, { bufferedOutput: "memory" }) as RendererHandle
+    expect(second).toBeTruthy()
+    const before = lib.getCursorState(second)
+    lib.setCursorPosition(rendererHandle, 2, 2, true)
+    expect(lib.getCursorState(second).x).toBe(before.x)
+    expect(lib.getCursorState(second).y).toBe(before.y)
+    lib.destroyRenderer(second)
+  })
+
+  test("buffer stale and wrong-kind handles are rejected", () => {
+    const lib = resolveRenderLib()
+    const buffer = OptimizedBuffer.create(4, 3, "unicode")
+    expect(buffer.buffers.char.length).toBe(12)
+    const bufferHandle = buffer.ptr
+    buffer.destroy()
+    expect(() => buffer.buffers).toThrow()
+    expect(() => buffer.fillRect(0, 0, 1, 1, RGBA.fromValues(1, 0, 0, 1))).toThrow("is destroyed")
+
+    expect(lib.getBufferWidth(bufferHandle)).toBe(0)
+    lib.destroyOptimizedBuffer(bufferHandle)
+
+    const renderer = lib.createRenderer(4, 3, { bufferedOutput: "memory" }) as RendererHandle
+    expect(lib.getBufferWidth(renderer as unknown as OptimizedBufferHandle)).toBe(0)
+    lib.destroyRenderer(renderer)
+  })
+
+  test("text, view, edit, editor, and syntax stale handles are rejected", () => {
+    const lib = resolveRenderLib()
+
+    const textBuffer = TextBuffer.create("unicode")
+    const textHandle = textBuffer.ptr
+    const textView = TextBufferView.create(textBuffer)
+    const textViewHandle = textView.ptr
+    textView.destroy()
+    expect(lib.textBufferViewGetVirtualLineCount(textViewHandle)).toBe(0)
+    textBuffer.destroy()
+    expect(lib.textBufferGetLength(textHandle)).toBe(0)
+
+    const editBuffer = EditBuffer.create("unicode")
+    const editHandle = editBuffer.ptr
+    const borrowedTextHandle = lib.editBufferGetTextBuffer(editHandle)
+    const editorView = EditorView.create(editBuffer, 10, 4)
+    const editorHandle = editorView.ptr
+    const borrowedViewHandle = lib.editorViewGetTextBufferView(editorHandle)
+    editorView.destroy()
+    expect(lib.textBufferViewGetVirtualLineCount(borrowedViewHandle)).toBe(0)
+    editBuffer.destroy()
+    expect(lib.editBufferGetId(editHandle)).toBe(0)
+    expect(lib.textBufferGetLength(borrowedTextHandle)).toBe(0)
+
+    const style = SyntaxStyle.create()
+    const styleHandle = style.ptr
+    style.destroy()
+    expect(lib.syntaxStyleGetStyleCount(styleHandle)).toBe(0)
+
+    expect(lib.textBufferGetLength(editHandle as unknown as TextBufferHandle)).toBe(0)
+  })
+
+  test("owned text buffer destroys child views", () => {
+    const lib = resolveRenderLib()
+    const textBuffer = TextBuffer.create("unicode")
+    const textView = TextBufferView.create(textBuffer)
+    const textViewHandle = textView.ptr
+
+    textBuffer.destroy()
+
+    expect(lib.textBufferViewGetVirtualLineCount(textViewHandle)).toBe(0)
+  })
+
+  test("borrowed edit buffer text handle cannot own text buffer views", () => {
+    const lib = resolveRenderLib()
+    const editBuffer = EditBuffer.create("unicode")
+    const editHandle = editBuffer.ptr
+    const borrowedTextHandle = lib.editBufferGetTextBuffer(editHandle)
+
+    expect(() => lib.createTextBufferView(borrowedTextHandle)).toThrow("Failed to create TextBufferView")
+
+    editBuffer.destroy()
+    expect(lib.textBufferGetLength(borrowedTextHandle)).toBe(0)
+  })
+})
+
+describe("native renderable measure target contract", () => {
+  test("rejects null nodes, unknown kinds, and stale target handles", () => {
+    const lib = resolveRenderLib()
+    const textBuffer = TextBuffer.create("unicode")
+    const textView = TextBufferView.create(textBuffer)
+    const node = Yoga.Node.createForOpenTUI()
+    const renderable = lib.createNativeRenderable()
+
+    try {
+      expect(lib.nativeRenderableAttachYogaNode(renderable, 0 as unknown as Pointer)).toBe(false)
+      expect(lib.nativeRenderableAttachYogaNode(renderable, node.ptr)).toBe(true)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(false)
+
+      expect(
+        lib.nativeRenderableSetMeasureTarget(renderable, NativeMeasureTargetKind.TextBufferView, textView.ptr),
+      ).toBe(true)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(true)
+
+      // Unknown kinds are rejected and leave the current target in place.
+      expect(
+        lib.nativeRenderableSetMeasureTarget(renderable, 999 as unknown as NativeMeasureTargetKind, textView.ptr),
+      ).toBe(false)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(true)
+
+      // Clear the target before destroying the view: a native renderable must
+      // never keep measuring a destroyed view (renderables enforce this by
+      // destroying the native renderable before their views).
+      expect(lib.nativeRenderableSetMeasureTarget(renderable, NativeMeasureTargetKind.None, 0)).toBe(true)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(false)
+
+      const staleViewHandle = textView.ptr
+      textView.destroy()
+      expect(
+        lib.nativeRenderableSetMeasureTarget(renderable, NativeMeasureTargetKind.TextBufferView, staleViewHandle),
+      ).toBe(false)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(false)
+    } finally {
+      lib.destroyNativeRenderable(renderable)
+      node.free()
+      textView.destroy()
+      textBuffer.destroy()
+    }
+  })
+
+  test("kind None clears the measure target", () => {
+    const lib = resolveRenderLib()
+    const editBuffer = EditBuffer.create("unicode")
+    const editorView = EditorView.create(editBuffer, 10, 4)
+    const node = Yoga.Node.createForOpenTUI()
+    const renderable = lib.createNativeRenderable()
+
+    try {
+      expect(lib.nativeRenderableAttachYogaNode(renderable, node.ptr)).toBe(true)
+      expect(lib.nativeRenderableSetMeasureTarget(renderable, NativeMeasureTargetKind.EditorView, editorView.ptr)).toBe(
+        true,
+      )
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(true)
+
+      expect(lib.nativeRenderableSetMeasureTarget(renderable, NativeMeasureTargetKind.None, 0)).toBe(true)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(false)
+    } finally {
+      lib.destroyNativeRenderable(renderable)
+      node.free()
+      editorView.destroy()
+      editBuffer.destroy()
+    }
+  })
+
+  test("destroying a native renderable clears the node measure func and invalidates the handle", () => {
+    const lib = resolveRenderLib()
+    const textBuffer = TextBuffer.create("unicode")
+    const textView = TextBufferView.create(textBuffer)
+    const node = Yoga.Node.createForOpenTUI()
+    const renderable = lib.createNativeRenderable()
+
+    try {
+      expect(lib.nativeRenderableAttachYogaNode(renderable, node.ptr)).toBe(true)
+      expect(
+        lib.nativeRenderableSetMeasureTarget(renderable, NativeMeasureTargetKind.TextBufferView, textView.ptr),
+      ).toBe(true)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(true)
+
+      lib.destroyNativeRenderable(renderable)
+      expect(lib.yogaNodeHasMeasureFunc(node.ptr)).toBe(false)
+
+      // Stale native renderable handles are rejected safely, including double destroy.
+      lib.destroyNativeRenderable(renderable)
+      expect(lib.nativeRenderableAttachYogaNode(renderable, node.ptr)).toBe(false)
+      expect(
+        lib.nativeRenderableSetMeasureTarget(renderable, NativeMeasureTargetKind.TextBufferView, textView.ptr),
+      ).toBe(false)
+    } finally {
+      node.free()
+      textView.destroy()
+      textBuffer.destroy()
+    }
+  })
+})