@xincli/opentui-core 0.4.6 → 0.4.7

package/src/lib/yoga.options.ts

@@ -1,346 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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()
-    }
-  })
-})