@xincli/opentui-core 0.4.6

package/src/lib/ascii.font.ts

@@ -0,0 +1,330 @@
+import { OptimizedBuffer } from "../buffer.js"
+import { parseColor, RGBA, type ColorInput } from "./RGBA.js"
+import block from "./fonts/block.json" with { type: "json" }
+import shade from "./fonts/shade.json" with { type: "json" }
+import slick from "./fonts/slick.json" with { type: "json" }
+import tiny from "./fonts/tiny.json" with { type: "json" }
+import huge from "./fonts/huge.json" with { type: "json" }
+import grid from "./fonts/grid.json" with { type: "json" }
+import pallet from "./fonts/pallet.json" with { type: "json" }
+
+/*
+ * Renders ASCII fonts to a buffer.
+ * Font definitions plugged from cfonts - https://github.com/dominikwilkowski/cfonts
+ */
+
+export type ASCIIFontName = "tiny" | "block" | "shade" | "slick" | "huge" | "grid" | "pallet"
+
+export const fonts = {
+  tiny,
+  block,
+  shade,
+  slick,
+  huge,
+  grid,
+  pallet,
+}
+
+type FontSegment = {
+  text: string
+  colorIndex: number
+}
+
+type FontDefinition = {
+  name: string
+  lines: number
+  letterspace_size: number
+  letterspace: string[]
+  colors?: number
+  chars: Record<string, string[]>
+}
+
+type ParsedFontDefinition = {
+  name: string
+  lines: number
+  letterspace_size: number
+  letterspace: string[]
+  colors: number
+  chars: Record<string, FontSegment[][]>
+}
+
+const parsedFonts: Record<string, ParsedFontDefinition> = {}
+
+function parseColorTags(text: string): FontSegment[] {
+  const segments: FontSegment[] = []
+  let currentIndex = 0
+
+  const colorTagRegex = /<c(\d+)>(.*?)<\/c\d+>/g
+  let lastIndex = 0
+  let match
+
+  while ((match = colorTagRegex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      const plainText = text.slice(lastIndex, match.index)
+      if (plainText) {
+        segments.push({ text: plainText, colorIndex: 0 })
+      }
+    }
+
+    const colorIndex = parseInt(match[1]) - 1
+    const taggedText = match[2]
+    segments.push({ text: taggedText, colorIndex: Math.max(0, colorIndex) })
+
+    lastIndex = match.index + match[0].length
+  }
+
+  if (lastIndex < text.length) {
+    const remainingText = text.slice(lastIndex)
+    if (remainingText) {
+      segments.push({ text: remainingText, colorIndex: 0 })
+    }
+  }
+
+  return segments
+}
+
+function getParsedFont(fontKey: keyof typeof fonts): ParsedFontDefinition {
+  if (!parsedFonts[fontKey]) {
+    const fontDef = fonts[fontKey] as FontDefinition
+    const parsedChars: Record<string, FontSegment[][]> = {}
+
+    for (const [char, lines] of Object.entries(fontDef.chars)) {
+      parsedChars[char] = lines.map((line) => parseColorTags(line))
+    }
+
+    parsedFonts[fontKey] = {
+      ...fontDef,
+      colors: fontDef.colors || 1,
+      chars: parsedChars,
+    }
+  }
+
+  return parsedFonts[fontKey]
+}
+
+export function measureText({ text, font = "tiny" }: { text: string; font?: keyof typeof fonts }): {
+  width: number
+  height: number
+} {
+  const fontDef = getParsedFont(font)
+  if (!fontDef) {
+    console.warn(`Font '${font}' not found`)
+    return { width: 0, height: 0 }
+  }
+
+  let currentX = 0
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i].toUpperCase()
+    const charDef = fontDef.chars[char]
+
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "]
+      if (spaceChar && spaceChar[0]) {
+        let spaceWidth = 0
+        for (const segment of spaceChar[0]) {
+          spaceWidth += segment.text.length
+        }
+        currentX += spaceWidth
+      } else {
+        currentX += 1
+      }
+      continue
+    }
+
+    let charWidth = 0
+    if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length
+      }
+    }
+
+    currentX += charWidth
+
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size
+    }
+  }
+
+  return {
+    width: currentX,
+    height: fontDef.lines,
+  }
+}
+
+export function getCharacterPositions(text: string, font: keyof typeof fonts = "tiny"): number[] {
+  const fontDef = getParsedFont(font)
+  if (!fontDef) {
+    return [0]
+  }
+
+  const positions: number[] = [0]
+  let currentX = 0
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i].toUpperCase()
+    const charDef = fontDef.chars[char]
+
+    let charWidth = 0
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "]
+      if (spaceChar && spaceChar[0]) {
+        for (const segment of spaceChar[0]) {
+          charWidth += segment.text.length
+        }
+      } else {
+        charWidth = 1
+      }
+    } else if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length
+      }
+    }
+
+    currentX += charWidth
+
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size
+    }
+
+    positions.push(currentX)
+  }
+
+  return positions
+}
+
+export function coordinateToCharacterIndex(x: number, text: string, font: keyof typeof fonts = "tiny"): number {
+  const positions = getCharacterPositions(text, font)
+
+  if (x < 0) {
+    return 0
+  }
+
+  for (let i = 0; i < positions.length - 1; i++) {
+    const currentPos = positions[i]
+    const nextPos = positions[i + 1]
+
+    if (x >= currentPos && x < nextPos) {
+      const charMidpoint = currentPos + (nextPos - currentPos) / 2
+      return x < charMidpoint ? i : i + 1
+    }
+  }
+
+  if (positions.length > 0 && x >= positions[positions.length - 1]) {
+    return text.length
+  }
+
+  return 0
+}
+
+export function renderFontToFrameBuffer(
+  buffer: OptimizedBuffer,
+  {
+    text,
+    x = 0,
+    y = 0,
+    color = [RGBA.fromInts(255, 255, 255, 255)],
+    backgroundColor = RGBA.fromInts(0, 0, 0, 255),
+    font = "tiny",
+  }: {
+    text: string
+    x?: number
+    y?: number
+    color?: ColorInput | ColorInput[]
+    backgroundColor?: ColorInput
+    font?: keyof typeof fonts
+  },
+): { width: number; height: number } {
+  const width = buffer.width
+  const height = buffer.height
+
+  const fontDef = getParsedFont(font)
+  if (!fontDef) {
+    console.warn(`Font '${font}' not found`)
+    return { width: 0, height: 0 }
+  }
+
+  const colors = Array.isArray(color) ? color : [color]
+
+  if (y < 0 || y + fontDef.lines > height) {
+    return { width: 0, height: fontDef.lines }
+  }
+
+  let currentX = x
+  const startX = x
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i].toUpperCase()
+    const charDef = fontDef.chars[char]
+
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "]
+      if (spaceChar && spaceChar[0]) {
+        let spaceWidth = 0
+        for (const segment of spaceChar[0]) {
+          spaceWidth += segment.text.length
+        }
+        currentX += spaceWidth
+      } else {
+        currentX += 1
+      }
+      continue
+    }
+
+    let charWidth = 0
+    if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length
+      }
+    }
+
+    if (currentX >= width) break
+    if (currentX + charWidth < 0) {
+      currentX += charWidth + fontDef.letterspace_size
+      continue
+    }
+
+    for (let lineIdx = 0; lineIdx < fontDef.lines && lineIdx < charDef.length; lineIdx++) {
+      const segments = charDef[lineIdx]
+      const renderY = y + lineIdx
+
+      if (renderY >= 0 && renderY < height) {
+        let segmentX = currentX
+
+        for (const segment of segments) {
+          const segmentColor = colors[segment.colorIndex] || colors[0]
+
+          for (let charIdx = 0; charIdx < segment.text.length; charIdx++) {
+            const renderX = segmentX + charIdx
+
+            if (renderX >= 0 && renderX < width) {
+              const fontChar = segment.text[charIdx]
+              if (fontChar !== " ") {
+                buffer.setCellWithAlphaBlending(
+                  renderX,
+                  renderY,
+                  fontChar,
+                  parseColor(segmentColor),
+                  parseColor(backgroundColor),
+                )
+              }
+            }
+          }
+
+          segmentX += segment.text.length
+        }
+      }
+    }
+
+    currentX += charWidth
+
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size
+    }
+  }
+
+  return {
+    width: currentX - startX,
+    height: fontDef.lines,
+  }
+}

package/src/lib/border.test.ts

@@ -0,0 +1,83 @@
+import { test, expect, describe, spyOn, afterEach } from "bun:test"
+import { isValidBorderStyle, parseBorderStyle, type BorderStyle } from "./border.js"
+
+describe("isValidBorderStyle", () => {
+  test("returns true for valid border styles", () => {
+    expect(isValidBorderStyle("single")).toBe(true)
+    expect(isValidBorderStyle("double")).toBe(true)
+    expect(isValidBorderStyle("rounded")).toBe(true)
+    expect(isValidBorderStyle("heavy")).toBe(true)
+  })
+
+  test("returns false for invalid border styles", () => {
+    expect(isValidBorderStyle("invalid")).toBe(false)
+    expect(isValidBorderStyle("")).toBe(false)
+    expect(isValidBorderStyle(null)).toBe(false)
+    expect(isValidBorderStyle(undefined)).toBe(false)
+    expect(isValidBorderStyle(123)).toBe(false)
+    expect(isValidBorderStyle({})).toBe(false)
+    expect(isValidBorderStyle([])).toBe(false)
+  })
+})
+
+describe("parseBorderStyle", () => {
+  let warnSpy: ReturnType<typeof spyOn>
+
+  afterEach(() => {
+    warnSpy?.mockRestore()
+  })
+
+  test("returns valid border styles unchanged", () => {
+    expect(parseBorderStyle("single")).toBe("single")
+    expect(parseBorderStyle("double")).toBe("double")
+    expect(parseBorderStyle("rounded")).toBe("rounded")
+    expect(parseBorderStyle("heavy")).toBe("heavy")
+  })
+
+  test("falls back to 'single' for invalid string values", () => {
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {})
+
+    expect(parseBorderStyle("invalid")).toBe("single")
+    expect(parseBorderStyle("")).toBe("single")
+    expect(parseBorderStyle("SINGLE")).toBe("single") // case sensitive
+    expect(parseBorderStyle("Single")).toBe("single")
+  })
+
+  test("falls back to custom fallback for invalid values", () => {
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {})
+
+    expect(parseBorderStyle("invalid", "double")).toBe("double")
+    expect(parseBorderStyle("invalid", "rounded")).toBe("rounded")
+    expect(parseBorderStyle("invalid", "heavy")).toBe("heavy")
+  })
+
+  test("falls back silently for undefined/null without warning", () => {
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {})
+
+    expect(parseBorderStyle(undefined)).toBe("single")
+    expect(parseBorderStyle(null)).toBe("single")
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+
+  test("logs warning for invalid non-null/undefined values", () => {
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {})
+
+    parseBorderStyle("invalid-style")
+
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    expect(warnSpy).toHaveBeenCalledWith(
+      'Invalid borderStyle "invalid-style", falling back to "single". Valid values are: single, double, rounded, heavy',
+    )
+  })
+
+  describe("regression: does not crash with unexpected value types", () => {
+    test("handles invalid values", () => {
+      warnSpy = spyOn(console, "warn").mockImplementation(() => {})
+
+      expect(parseBorderStyle(123 as unknown as BorderStyle)).toBe("single")
+      expect(parseBorderStyle({} as unknown as BorderStyle)).toBe("single")
+      expect(parseBorderStyle(true as unknown as BorderStyle)).toBe("single")
+      expect(parseBorderStyle((() => "single") as unknown as BorderStyle)).toBe("single")
+    })
+  })
+})

package/src/lib/border.ts

@@ -0,0 +1,170 @@
+import type { ColorInput } from "./RGBA.js"
+
+export interface BorderCharacters {
+  topLeft: string
+  topRight: string
+  bottomLeft: string
+  bottomRight: string
+  horizontal: string
+  vertical: string
+  topT: string
+  bottomT: string
+  leftT: string
+  rightT: string
+  cross: string
+}
+
+export type BorderStyle = "single" | "double" | "rounded" | "heavy"
+export type BorderSides = "top" | "right" | "bottom" | "left"
+
+const VALID_BORDER_STYLES: readonly BorderStyle[] = ["single", "double", "rounded", "heavy"] as const
+
+export function isValidBorderStyle(value: unknown): value is BorderStyle {
+  return typeof value === "string" && VALID_BORDER_STYLES.includes(value as BorderStyle)
+}
+
+export function parseBorderStyle(value: unknown, fallback: BorderStyle = "single"): BorderStyle {
+  if (isValidBorderStyle(value)) {
+    return value
+  }
+
+  if (value !== undefined && value !== null) {
+    console.warn(
+      `Invalid borderStyle "${value}", falling back to "${fallback}". Valid values are: ${VALID_BORDER_STYLES.join(", ")}`,
+    )
+  }
+  return fallback
+}
+
+export const BorderChars: Record<BorderStyle, BorderCharacters> = {
+  single: {
+    topLeft: "┌",
+    topRight: "┐",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    horizontal: "─",
+    vertical: "│",
+    topT: "┬",
+    bottomT: "┴",
+    leftT: "├",
+    rightT: "┤",
+    cross: "┼",
+  },
+  double: {
+    topLeft: "╔",
+    topRight: "╗",
+    bottomLeft: "╚",
+    bottomRight: "╝",
+    horizontal: "═",
+    vertical: "║",
+    topT: "╦",
+    bottomT: "╩",
+    leftT: "╠",
+    rightT: "╣",
+    cross: "╬",
+  },
+  rounded: {
+    topLeft: "╭",
+    topRight: "╮",
+    bottomLeft: "╰",
+    bottomRight: "╯",
+    horizontal: "─",
+    vertical: "│",
+    topT: "┬",
+    bottomT: "┴",
+    leftT: "├",
+    rightT: "┤",
+    cross: "┼",
+  },
+  heavy: {
+    topLeft: "┏",
+    topRight: "┓",
+    bottomLeft: "┗",
+    bottomRight: "┛",
+    horizontal: "━",
+    vertical: "┃",
+    topT: "┳",
+    bottomT: "┻",
+    leftT: "┣",
+    rightT: "┫",
+    cross: "╋",
+  },
+}
+
+export interface BorderConfig {
+  borderStyle: BorderStyle
+  border: boolean | BorderSides[]
+  borderColor?: ColorInput
+  customBorderChars?: BorderCharacters
+}
+
+export interface BoxDrawOptions {
+  x: number
+  y: number
+  width: number
+  height: number
+  borderStyle: BorderStyle
+  border: boolean | BorderSides[]
+  borderColor: ColorInput
+  customBorderChars?: BorderCharacters
+  backgroundColor: ColorInput
+  shouldFill?: boolean
+  title?: string
+  titleAlignment?: "left" | "center" | "right"
+  bottomTitle?: string
+  bottomTitleAlignment?: "left" | "center" | "right"
+}
+
+export interface BorderSidesConfig {
+  top: boolean
+  right: boolean
+  bottom: boolean
+  left: boolean
+}
+
+export function getBorderFromSides(sides: BorderSidesConfig): boolean | BorderSides[] {
+  const result: BorderSides[] = []
+  if (sides.top) result.push("top")
+  if (sides.right) result.push("right")
+  if (sides.bottom) result.push("bottom")
+  if (sides.left) result.push("left")
+  return result.length > 0 ? result : false
+}
+
+export function getBorderSides(border: boolean | BorderSides[]): BorderSidesConfig {
+  return border === true
+    ? { top: true, right: true, bottom: true, left: true }
+    : Array.isArray(border)
+      ? {
+          top: border.includes("top"),
+          right: border.includes("right"),
+          bottom: border.includes("bottom"),
+          left: border.includes("left"),
+        }
+      : { top: false, right: false, bottom: false, left: false }
+}
+
+// Convert BorderCharacters to Uint32Array for passing to Zig
+export function borderCharsToArray(chars: BorderCharacters): Uint32Array {
+  const array = new Uint32Array(11)
+  array[0] = chars.topLeft.codePointAt(0)!
+  array[1] = chars.topRight.codePointAt(0)!
+  array[2] = chars.bottomLeft.codePointAt(0)!
+  array[3] = chars.bottomRight.codePointAt(0)!
+  array[4] = chars.horizontal.codePointAt(0)!
+  array[5] = chars.vertical.codePointAt(0)!
+  array[6] = chars.topT.codePointAt(0)!
+  array[7] = chars.bottomT.codePointAt(0)!
+  array[8] = chars.leftT.codePointAt(0)!
+  array[9] = chars.rightT.codePointAt(0)!
+  array[10] = chars.cross.codePointAt(0)!
+  return array
+}
+
+// Pre-converted border character arrays for performance
+export const BorderCharArrays: Record<BorderStyle, Uint32Array> = {
+  single: borderCharsToArray(BorderChars.single),
+  double: borderCharsToArray(BorderChars.double),
+  rounded: borderCharsToArray(BorderChars.rounded),
+  heavy: borderCharsToArray(BorderChars.heavy),
+}

package/src/lib/bunfs.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test"
+import { isBunfsPath, getBunfsRootPath } from "./bunfs.js"
+
+describe("bunfs", () => {
+  test("isBunfsPath detects $bunfs paths", () => {
+    expect(isBunfsPath("/$bunfs/root/file.wasm")).toBe(true)
+  })
+
+  test("isBunfsPath detects Windows B: paths", () => {
+    expect(isBunfsPath("B:\\~BUN\\root\\file.wasm")).toBe(true)
+    expect(isBunfsPath("B:/~BUN/root/file.wasm")).toBe(true)
+  })
+
+  test("isBunfsPath ignores regular paths", () => {
+    expect(isBunfsPath("/usr/local/bin/file")).toBe(false)
+    expect(isBunfsPath("C:/Users/file.wasm")).toBe(false)
+  })
+
+  test("getBunfsRootPath", () => {
+    const root = getBunfsRootPath()
+    if (process.platform === "win32") {
+      expect(root).toBe("B:\\~BUN\\root")
+    } else {
+      expect(root).toBe("/$bunfs/root")
+    }
+  })
+})

package/src/lib/bunfs.ts

@@ -0,0 +1,18 @@
+import { basename, join } from "node:path"
+
+export function isBunfsPath(path: string): boolean {
+  // Removed ambiguous '//' check
+  return path.includes("$bunfs") || /^B:[\\/]~BUN/i.test(path)
+}
+
+export function getBunfsRootPath(): string {
+  return process.platform === "win32" ? "B:\\~BUN\\root" : "/$bunfs/root"
+}
+
+/**
+ * Normalizes a path to the embedded root.
+ * Flattens directory structure to ensure file exists at root.
+ */
+export function normalizeBunfsPath(fileName: string): string {
+  return join(getBunfsRootPath(), basename(fileName))
+}

package/src/lib/clipboard.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it, afterEach } from "bun:test"
+import { createTestRenderer, type TestRenderer } from "../testing/test-renderer.js"
+import { Clipboard, ClipboardTarget } from "./clipboard.js"
+import type { RendererHandle, RenderLib } from "../zig.js"
+
+describe("clipboard", () => {
+  let renderer: TestRenderer | null = null
+
+  const respondToOsc52Query = (testRenderer: TestRenderer, response: string) => {
+    const lib = (testRenderer as unknown as { lib: RenderLib }).lib
+    lib.processCapabilityResponse(testRenderer.rendererPtr, response)
+  }
+
+  afterEach(() => {
+    renderer?.destroy()
+    renderer = null
+  })
+
+  it("preserves the native selection target ABI", () => {
+    expect(ClipboardTarget.Clipboard).toBe(0)
+    expect(ClipboardTarget.Primary).toBe(1)
+    expect(ClipboardTarget.Select).toBe(2)
+    expect(ClipboardTarget.Secondary).toBe(3)
+  })
+
+  it("passes raw UTF-8 bytes to the native encoder", () => {
+    let received: Uint8Array | undefined
+    const lib = {
+      encoder: new TextEncoder(),
+      getTerminalCapabilities: () => ({ osc52_support: "unknown" }),
+      copyToClipboardOSC52: (_renderer: RendererHandle, _target: number, textUtf8: Uint8Array) => {
+        received = textUtf8
+        return true
+      },
+    } as unknown as RenderLib
+    const clipboard = new Clipboard(lib, 0 as unknown as RendererHandle)
+
+    expect(clipboard.copyToClipboardOSC52("世界")).toBe(true)
+    expect(received).toEqual(new TextEncoder().encode("世界"))
+  })
+
+  it("treats negative XTGETTCAP Ms replies as inconclusive", async () => {
+    ;({ renderer } = await createTestRenderer({ remote: true }))
+
+    expect(renderer.isOsc52Supported()).toBe(true)
+    expect(renderer.copyToClipboardOSC52("test")).toBe(true)
+
+    respondToOsc52Query(renderer, "\x1bP0+r\x1b\\")
+    expect(renderer.copyToClipboardOSC52("test")).toBe(true)
+    expect(renderer.clearClipboardOSC52()).toBe(true)
+
+    respondToOsc52Query(renderer, "\x1bP0+r4d73\x1b\\")
+    expect(renderer.copyToClipboardOSC52("test")).toBe(true)
+
+    respondToOsc52Query(renderer, "\x1bP1+r4d73=2570312573\x1b\\")
+
+    expect(renderer.copyToClipboardOSC52("test")).toBe(true)
+    expect(renderer.copyToClipboardOSC52("test", ClipboardTarget.Primary)).toBe(true)
+    expect(renderer.copyToClipboardOSC52("test", ClipboardTarget.Select)).toBe(true)
+    expect(renderer.copyToClipboardOSC52("test", ClipboardTarget.Secondary)).toBe(true)
+    expect(renderer.clearClipboardOSC52()).toBe(true)
+  })
+})