@xincli/opentui-core 0.4.6 → 0.4.7

package/src/lib/ascii.font.ts

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

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

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

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

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

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