@xincli/opentui-core 0.4.6 → 0.4.7

package/src/lib/KeyHandler.ts

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

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

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