@xincli/opentui-core 0.4.6

package/src/lib/KeyHandler.ts

@@ -0,0 +1,222 @@
+import { EventEmitter } from "events"
+import { type KeyEventType, type ParsedKey } from "./parse.keypress.js"
+import type { PasteMetadata } from "./paste.js"
+
+export class KeyEvent implements ParsedKey {
+  name: string
+  ctrl: boolean
+  meta: boolean
+  shift: boolean
+  option: boolean
+  sequence: string
+  number: boolean
+  raw: string
+  eventType: KeyEventType
+  source: "raw" | "kitty"
+  code?: string
+  super?: boolean
+  hyper?: boolean
+  capsLock?: boolean
+  numLock?: boolean
+  baseCode?: number
+  repeated?: boolean
+
+  private _defaultPrevented: boolean = false
+  private _propagationStopped: boolean = false
+
+  constructor(key: ParsedKey) {
+    this.name = key.name
+    this.ctrl = key.ctrl
+    this.meta = key.meta
+    this.shift = key.shift
+    this.option = key.option
+    this.sequence = key.sequence
+    this.number = key.number
+    this.raw = key.raw
+    this.eventType = key.eventType
+    this.source = key.source
+    this.code = key.code
+    this.super = key.super
+    this.hyper = key.hyper
+    this.capsLock = key.capsLock
+    this.numLock = key.numLock
+    this.baseCode = key.baseCode
+    this.repeated = key.repeated
+  }
+
+  get defaultPrevented(): boolean {
+    return this._defaultPrevented
+  }
+
+  get propagationStopped(): boolean {
+    return this._propagationStopped
+  }
+
+  preventDefault(): void {
+    this._defaultPrevented = true
+  }
+
+  stopPropagation(): void {
+    this._propagationStopped = true
+  }
+}
+
+export class PasteEvent {
+  type = "paste" as const
+  bytes: Uint8Array
+  metadata?: PasteMetadata
+  private _defaultPrevented: boolean = false
+  private _propagationStopped: boolean = false
+
+  constructor(bytes: Uint8Array, metadata?: PasteMetadata) {
+    this.bytes = bytes
+    this.metadata = metadata
+  }
+
+  get defaultPrevented(): boolean {
+    return this._defaultPrevented
+  }
+
+  get propagationStopped(): boolean {
+    return this._propagationStopped
+  }
+
+  preventDefault(): void {
+    this._defaultPrevented = true
+  }
+
+  stopPropagation(): void {
+    this._propagationStopped = true
+  }
+}
+
+export type KeyHandlerEventMap = {
+  keypress: [KeyEvent]
+  keyrelease: [KeyEvent]
+  paste: [PasteEvent]
+}
+
+export class KeyHandler extends EventEmitter<KeyHandlerEventMap> {
+  public processParsedKey(parsedKey: ParsedKey): boolean {
+    try {
+      switch (parsedKey.eventType) {
+        case "press":
+          this.emit("keypress", new KeyEvent(parsedKey))
+          break
+        case "release":
+          this.emit("keyrelease", new KeyEvent(parsedKey))
+          break
+        default:
+          this.emit("keypress", new KeyEvent(parsedKey))
+          break
+      }
+    } catch (error) {
+      console.error(`[KeyHandler] Error processing parsed key:`, error)
+      return true
+    }
+
+    return true
+  }
+
+  public processPaste(bytes: Uint8Array, metadata?: PasteMetadata): void {
+    try {
+      this.emit("paste", new PasteEvent(bytes, metadata))
+    } catch (error) {
+      console.error(`[KeyHandler] Error processing paste:`, error)
+    }
+  }
+}
+
+/**
+ * This class is used internally by the renderer to ensure global handlers
+ * can preventDefault before renderable handlers process events.
+ */
+export class InternalKeyHandler extends KeyHandler {
+  private renderableHandlers: Map<keyof KeyHandlerEventMap, Set<Function>> = new Map()
+
+  public emit<K extends keyof KeyHandlerEventMap>(event: K, ...args: KeyHandlerEventMap[K]): boolean {
+    return this.emitWithPriority(event, ...args)
+  }
+
+  private emitWithPriority<K extends keyof KeyHandlerEventMap>(event: K, ...args: KeyHandlerEventMap[K]): boolean {
+    let hasGlobalListeners = false
+
+    // Check if we should emit to global handlers
+    // Global handlers are emitted using the parent EventEmitter which calls all listeners
+    // We need to manually iterate to check for stopPropagation between handlers
+    const globalListeners = this.listeners(event as any)
+    if (globalListeners.length > 0) {
+      hasGlobalListeners = true
+
+      for (const listener of globalListeners) {
+        try {
+          listener(...args)
+        } catch (error) {
+          console.error(`[KeyHandler] Error in global ${event} handler:`, error)
+        }
+
+        // Check if propagation was stopped after this handler
+        if (event === "keypress" || event === "keyrelease" || event === "paste") {
+          const keyEvent = args[0]
+          if (keyEvent.propagationStopped) {
+            return hasGlobalListeners
+          }
+        }
+      }
+    }
+
+    const renderableSet = this.renderableHandlers.get(event)
+    // Snapshot the handler list so listeners added during dispatch (e.g., via focus changes)
+    // do not receive the in-flight key event.
+    const renderableHandlers = renderableSet && renderableSet.size > 0 ? [...renderableSet] : []
+    let hasRenderableListeners = false
+
+    if (renderableSet && renderableSet.size > 0) {
+      hasRenderableListeners = true
+
+      if (event === "keypress" || event === "keyrelease" || event === "paste") {
+        const keyEvent = args[0]
+        if (keyEvent.defaultPrevented) return hasGlobalListeners || hasRenderableListeners
+        if (keyEvent.propagationStopped) return hasGlobalListeners || hasRenderableListeners
+      }
+
+      for (const handler of renderableHandlers) {
+        try {
+          handler(...args)
+        } catch (error) {
+          console.error(`[KeyHandler] Error in renderable ${event} handler:`, error)
+        }
+
+        // Check if propagation was stopped after this handler
+        if (event === "keypress" || event === "keyrelease" || event === "paste") {
+          const keyEvent = args[0]
+          if (keyEvent.propagationStopped) {
+            return hasGlobalListeners || hasRenderableListeners
+          }
+        }
+      }
+    }
+
+    return hasGlobalListeners || hasRenderableListeners
+  }
+
+  public onInternal<K extends keyof KeyHandlerEventMap>(
+    event: K,
+    handler: (...args: KeyHandlerEventMap[K]) => void,
+  ): void {
+    if (!this.renderableHandlers.has(event)) {
+      this.renderableHandlers.set(event, new Set())
+    }
+    this.renderableHandlers.get(event)!.add(handler)
+  }
+
+  public offInternal<K extends keyof KeyHandlerEventMap>(
+    event: K,
+    handler: (...args: KeyHandlerEventMap[K]) => void,
+  ): void {
+    const handlers = this.renderableHandlers.get(event)
+    if (handlers) {
+      handlers.delete(handler)
+    }
+  }
+}

package/src/lib/RGBA.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test"
+import { RGBA, ansi256IndexToRgb, hexToRgb, normalizeColorValue, parseColor, rgbToHex } from "./RGBA.js"
+
+describe("RGBA", () => {
+  test("uses packed Uint16 transport", () => {
+    const color = RGBA.fromValues(1, 0, 0, 0.5)
+    expect(color.buffer).toBeInstanceOf(Uint16Array)
+    expect(color.buffer).toHaveLength(4)
+    expect(color.toInts()).toEqual([255, 0, 0, 128])
+    expect(color.intent).toBe("rgb")
+  })
+
+  test("copies constructor input", () => {
+    const input = new Uint16Array([1, 2, 3, 4])
+    const color = new RGBA(input)
+    input[0] = 255
+    expect(color.buffer[0]).toBe(1)
+  })
+
+  test("preserves metadata when mutating channels", () => {
+    const color = RGBA.fromIndex(6)
+    color.r = 1
+    expect(color.intent).toBe("indexed")
+    expect(color.slot).toBe(6)
+    expect(color.toInts()[0]).toBe(255)
+  })
+
+  test("constructs indexed and default colors", () => {
+    const indexed = RGBA.fromIndex(12, "#112233")
+    const defaultFg = RGBA.defaultForeground("#abcdef")
+
+    expect(indexed.intent).toBe("indexed")
+    expect(indexed.slot).toBe(12)
+    expect(indexed.toInts()).toEqual([0x11, 0x22, 0x33, 255])
+    expect(defaultFg.intent).toBe("default")
+    expect(defaultFg.toInts()).toEqual([0xab, 0xcd, 0xef, 255])
+  })
+
+  test("converts ANSI 256 indexes", () => {
+    expect(ansi256IndexToRgb(9)).toEqual([255, 0, 0])
+    expect(ansi256IndexToRgb(21)).toEqual([0, 0, 255])
+    expect(ansi256IndexToRgb(232)).toEqual([8, 8, 8])
+  })
+
+  test("parses and formats colors", () => {
+    expect(hexToRgb("#F808").toInts()).toEqual([255, 136, 0, 136])
+    expect(parseColor("transparent").toInts()).toEqual([0, 0, 0, 0])
+    expect(rgbToHex(RGBA.fromInts(255, 128, 64, 128))).toBe("#ff804080")
+  })
+
+  test("normalizes ColorInput values", () => {
+    expect(normalizeColorValue(null)).toBeNull()
+    expect(normalizeColorValue("#123456")?.rgba.toInts()).toEqual([0x12, 0x34, 0x56, 255])
+  })
+
+  test("compares packed values exactly", () => {
+    expect(RGBA.fromIndex(4, "#0000ff").equals(RGBA.fromInts(0, 0, 255))).toBe(false)
+    expect(RGBA.clone(RGBA.fromIndex(4)).equals(RGBA.fromIndex(4))).toBe(true)
+  })
+})

package/src/lib/RGBA.ts

@@ -0,0 +1,343 @@
+export type RGBTriplet = readonly [number, number, number]
+export type ColorIntent = "rgb" | "indexed" | "default"
+export type ColorInput = string | RGBA
+
+export const DEFAULT_FOREGROUND_RGB: RGBTriplet = [255, 255, 255]
+export const DEFAULT_BACKGROUND_RGB: RGBTriplet = [0, 0, 0]
+
+const INTENT_RGB = 0
+const INTENT_INDEXED = 1
+const INTENT_DEFAULT = 2
+
+const ANSI16_RGB: readonly RGBTriplet[] = [
+  [0x00, 0x00, 0x00],
+  [0x80, 0x00, 0x00],
+  [0x00, 0x80, 0x00],
+  [0x80, 0x80, 0x00],
+  [0x00, 0x00, 0x80],
+  [0x80, 0x00, 0x80],
+  [0x00, 0x80, 0x80],
+  [0xc0, 0xc0, 0xc0],
+  [0x80, 0x80, 0x80],
+  [0xff, 0x00, 0x00],
+  [0x00, 0xff, 0x00],
+  [0xff, 0xff, 0x00],
+  [0x00, 0x00, 0xff],
+  [0xff, 0x00, 0xff],
+  [0x00, 0xff, 0xff],
+  [0xff, 0xff, 0xff],
+]
+
+const ANSI_256_CUBE_LEVELS = [0, 95, 135, 175, 215, 255] as const
+
+export interface NormalizedColorValue {
+  rgba: RGBA
+}
+
+function packMeta(intent: number, slot = 0): number {
+  return ((slot & 0xff) | ((intent & 0xff) << 8)) >>> 0
+}
+
+function toU8(value: number): number {
+  return Math.round(Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0)) * 255)
+}
+
+function toByte(value: number): number {
+  return Math.round(Math.max(0, Math.min(255, Number.isFinite(value) ? value : 0)))
+}
+
+function packRGBA8(r: number, g: number, b: number, a: number, meta: number): Uint16Array {
+  return new Uint16Array([
+    (toByte(r) & 0xff) | (((meta >>> 0) & 0xff) << 8),
+    (toByte(g) & 0xff) | (((meta >>> 8) & 0xff) << 8),
+    (toByte(b) & 0xff) | (((meta >>> 16) & 0xff) << 8),
+    (toByte(a) & 0xff) | (((meta >>> 24) & 0xff) << 8),
+  ])
+}
+
+function rgbaForAnsi256Index(index: number): RGBA {
+  const [r, g, b] = ansi256IndexToRgb(index)
+  return RGBA.fromInts(r, g, b)
+}
+
+export function normalizeIndexedColorIndex(index: number): number {
+  if (!Number.isInteger(index) || index < 0 || index > 255) {
+    throw new RangeError(`Indexed color must be an integer in the range 0..255, got ${index}`)
+  }
+
+  return index
+}
+
+export function ansi256IndexToRgb(index: number): RGBTriplet {
+  const normalizedIndex = normalizeIndexedColorIndex(index)
+
+  if (normalizedIndex < ANSI16_RGB.length) {
+    return ANSI16_RGB[normalizedIndex]
+  }
+
+  if (normalizedIndex < 232) {
+    const cubeIndex = normalizedIndex - 16
+    const r = Math.floor(cubeIndex / 36)
+    const g = Math.floor(cubeIndex / 6) % 6
+    const b = cubeIndex % 6
+    return [ANSI_256_CUBE_LEVELS[r], ANSI_256_CUBE_LEVELS[g], ANSI_256_CUBE_LEVELS[b]]
+  }
+
+  const value = 8 + (normalizedIndex - 232) * 10
+  return [value, value, value]
+}
+
+export class RGBA {
+  buffer: Uint16Array
+
+  constructor(buffer: Uint16Array) {
+    this.buffer = new Uint16Array(4)
+    this.buffer.set(buffer.subarray(0, 4))
+  }
+
+  static fromArray(array: Uint16Array): RGBA {
+    return new RGBA(array)
+  }
+
+  static fromValues(r: number, g: number, b: number, a: number = 1): RGBA {
+    return new RGBA(packRGBA8(toU8(r), toU8(g), toU8(b), toU8(a), packMeta(INTENT_RGB)))
+  }
+
+  static clone(rgba: RGBA): RGBA {
+    return new RGBA(rgba.buffer)
+  }
+
+  static fromInts(r: number, g: number, b: number, a: number = 255): RGBA {
+    return new RGBA(packRGBA8(r, g, b, a, packMeta(INTENT_RGB)))
+  }
+
+  static fromHex(hex: string): RGBA {
+    return hexToRgb(hex)
+  }
+
+  static fromIndex(index: number, snapshot?: ColorInput): RGBA {
+    const normalized = normalizeIndexedColorIndex(index)
+    const rgba = snapshot ? parseColor(snapshot) : rgbaForAnsi256Index(normalized)
+    const [r, g, b, a] = rgba.toInts()
+    return new RGBA(packRGBA8(r, g, b, a, packMeta(INTENT_INDEXED, normalized)))
+  }
+
+  static defaultForeground(snapshot?: ColorInput): RGBA {
+    const rgba = snapshot ? parseColor(snapshot) : RGBA.fromInts(...DEFAULT_FOREGROUND_RGB)
+    const [r, g, b, a] = rgba.toInts()
+    return new RGBA(packRGBA8(r, g, b, a, packMeta(INTENT_DEFAULT)))
+  }
+
+  static defaultBackground(snapshot?: ColorInput): RGBA {
+    const rgba = snapshot ? parseColor(snapshot) : RGBA.fromInts(...DEFAULT_BACKGROUND_RGB)
+    const [r, g, b, a] = rgba.toInts()
+    return new RGBA(packRGBA8(r, g, b, a, packMeta(INTENT_DEFAULT)))
+  }
+
+  toInts(): [number, number, number, number] {
+    return [this.buffer[0] & 0xff, this.buffer[1] & 0xff, this.buffer[2] & 0xff, this.buffer[3] & 0xff]
+  }
+
+  get r(): number {
+    return (this.buffer[0] & 0xff) / 255
+  }
+
+  set r(value: number) {
+    this.buffer[0] = (this.buffer[0] & 0xff00) | toU8(value)
+  }
+
+  get g(): number {
+    return (this.buffer[1] & 0xff) / 255
+  }
+
+  set g(value: number) {
+    this.buffer[1] = (this.buffer[1] & 0xff00) | toU8(value)
+  }
+
+  get b(): number {
+    return (this.buffer[2] & 0xff) / 255
+  }
+
+  set b(value: number) {
+    this.buffer[2] = (this.buffer[2] & 0xff00) | toU8(value)
+  }
+
+  get a(): number {
+    return (this.buffer[3] & 0xff) / 255
+  }
+
+  set a(value: number) {
+    this.buffer[3] = (this.buffer[3] & 0xff00) | toU8(value)
+  }
+
+  get meta(): number {
+    return (
+      ((this.buffer[0] >>> 8) |
+        ((this.buffer[1] >>> 8) << 8) |
+        ((this.buffer[2] >>> 8) << 16) |
+        ((this.buffer[3] >>> 8) << 24)) >>>
+      0
+    )
+  }
+
+  get intent(): ColorIntent {
+    switch ((this.meta >>> 8) & 0xff) {
+      case INTENT_INDEXED:
+        return "indexed"
+      case INTENT_DEFAULT:
+        return "default"
+      default:
+        return "rgb"
+    }
+  }
+
+  get slot(): number {
+    return this.meta & 0xff
+  }
+
+  map<R>(fn: (value: number) => R): [R, R, R, R] {
+    return [fn(this.r), fn(this.g), fn(this.b), fn(this.a)]
+  }
+
+  toString(): string {
+    return `rgba(${this.r.toFixed(2)}, ${this.g.toFixed(2)}, ${this.b.toFixed(2)}, ${this.a.toFixed(2)})`
+  }
+
+  equals(other?: RGBA): boolean {
+    if (!other) return false
+    return (
+      this.buffer[0] === other.buffer[0] &&
+      this.buffer[1] === other.buffer[1] &&
+      this.buffer[2] === other.buffer[2] &&
+      this.buffer[3] === other.buffer[3]
+    )
+  }
+}
+
+export function normalizeColorValue(value: ColorInput | null | undefined): NormalizedColorValue | null {
+  if (value == null) return null
+  return { rgba: parseColor(value) }
+}
+
+export function hexToRgb(hex: string): RGBA {
+  hex = hex.replace(/^#/, "")
+
+  if (hex.length === 3) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2]
+  } else if (hex.length === 4) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2] + hex[3] + hex[3]
+  }
+
+  if (!/^[0-9A-Fa-f]{6}$/.test(hex) && !/^[0-9A-Fa-f]{8}$/.test(hex)) {
+    console.warn(`Invalid hex color: ${hex}, defaulting to magenta`)
+    return RGBA.fromValues(1, 0, 1, 1)
+  }
+
+  const r = parseInt(hex.substring(0, 2), 16)
+  const g = parseInt(hex.substring(2, 4), 16)
+  const b = parseInt(hex.substring(4, 6), 16)
+  const a = hex.length === 8 ? parseInt(hex.substring(6, 8), 16) : 255
+
+  return RGBA.fromInts(r, g, b, a)
+}
+
+export function rgbToHex(rgb: RGBA): string {
+  const [r, g, b, a] = rgb.toInts()
+  const components = a === 255 ? [r, g, b] : [r, g, b, a]
+  return "#" + components.map((x) => x.toString(16).padStart(2, "0")).join("")
+}
+
+export function hsvToRgb(h: number, s: number, v: number): RGBA {
+  let r = 0,
+    g = 0,
+    b = 0
+
+  const i = Math.floor(h / 60) % 6
+  const f = h / 60 - Math.floor(h / 60)
+  const p = v * (1 - s)
+  const q = v * (1 - f * s)
+  const t = v * (1 - (1 - f) * s)
+
+  switch (i) {
+    case 0:
+      r = v
+      g = t
+      b = p
+      break
+    case 1:
+      r = q
+      g = v
+      b = p
+      break
+    case 2:
+      r = p
+      g = v
+      b = t
+      break
+    case 3:
+      r = p
+      g = q
+      b = v
+      break
+    case 4:
+      r = t
+      g = p
+      b = v
+      break
+    case 5:
+      r = v
+      g = p
+      b = q
+      break
+  }
+
+  return RGBA.fromValues(r, g, b, 1)
+}
+
+const CSS_COLOR_NAMES: Record<string, string> = {
+  black: "#000000",
+  white: "#FFFFFF",
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  yellow: "#FFFF00",
+  cyan: "#00FFFF",
+  magenta: "#FF00FF",
+  silver: "#C0C0C0",
+  gray: "#808080",
+  grey: "#808080",
+  maroon: "#800000",
+  olive: "#808000",
+  lime: "#00FF00",
+  aqua: "#00FFFF",
+  teal: "#008080",
+  navy: "#000080",
+  fuchsia: "#FF00FF",
+  purple: "#800080",
+  orange: "#FFA500",
+  brightblack: "#666666",
+  brightred: "#FF6666",
+  brightgreen: "#66FF66",
+  brightblue: "#6666FF",
+  brightyellow: "#FFFF66",
+  brightcyan: "#66FFFF",
+  brightmagenta: "#FF66FF",
+  brightwhite: "#FFFFFF",
+}
+
+export function parseColor(color: ColorInput): RGBA {
+  if (typeof color === "string") {
+    const lowerColor = color.toLowerCase()
+
+    if (lowerColor === "transparent") {
+      return RGBA.fromValues(0, 0, 0, 0)
+    }
+
+    if (CSS_COLOR_NAMES[lowerColor]) {
+      return hexToRgb(CSS_COLOR_NAMES[lowerColor])
+    }
+
+    return hexToRgb(color)
+  }
+  return color
+}