@xincli/opentui-core 0.4.6

package/src/testing/mock-mouse.ts

@@ -0,0 +1,247 @@
+import type { CliRenderer } from "../renderer.js"
+
+export const MouseButtons = {
+  LEFT: 0,
+  MIDDLE: 1,
+  RIGHT: 2,
+
+  WHEEL_UP: 64, // 64 = scroll flag + 0
+  WHEEL_DOWN: 65, // 64 + 1
+  WHEEL_LEFT: 66, // 64 + 2
+  WHEEL_RIGHT: 67, // 64 + 3
+} as const
+
+export type MouseButton = (typeof MouseButtons)[keyof typeof MouseButtons]
+
+export interface MousePosition {
+  x: number
+  y: number
+}
+
+export interface MouseModifiers {
+  shift?: boolean
+  alt?: boolean
+  ctrl?: boolean
+}
+
+export type MouseEventType = "down" | "up" | "move" | "drag" | "scroll"
+
+export interface MouseEventOptions {
+  button?: MouseButton
+  modifiers?: MouseModifiers
+  delayMs?: number
+}
+
+export function createMockMouse(renderer: CliRenderer) {
+  let currentPosition: MousePosition = { x: 0, y: 0 }
+  let buttonsPressed = new Set<MouseButton>()
+
+  // Generate SGR mouse event sequence
+  const generateMouseEvent = (
+    type: MouseEventType,
+    x: number,
+    y: number,
+    button: MouseButton = MouseButtons.LEFT,
+    modifiers: MouseModifiers = {},
+  ): string => {
+    // SGR format: \x1b[<b;x;yM or \x1b[<b;x;ym
+    // where b = button code + modifier flags + motion/scroll flags
+
+    let buttonCode: number = button
+
+    // Add modifier flags
+    if (modifiers.shift) buttonCode |= 4
+    if (modifiers.alt) buttonCode |= 8
+    if (modifiers.ctrl) buttonCode |= 16
+
+    switch (type) {
+      case "move":
+        buttonCode = 32 | 3 // motion flag (32) + button 3 for motion without button press
+        if (modifiers.shift) buttonCode |= 4
+        if (modifiers.alt) buttonCode |= 8
+        if (modifiers.ctrl) buttonCode |= 16
+        break
+      case "drag":
+        buttonCode = (buttonsPressed.size > 0 ? Array.from(buttonsPressed)[0] : button) | 32
+        if (modifiers.shift) buttonCode |= 4
+        if (modifiers.alt) buttonCode |= 8
+        if (modifiers.ctrl) buttonCode |= 16
+        break
+      case "scroll":
+        // Scroll events already have the scroll flag set in the button code
+        break
+    }
+
+    // Convert to 1-based coordinates for ANSI
+    const ansiX = x + 1
+    const ansiY = y + 1
+
+    let pressRelease = "M" // Default to press
+    if (type === "up" || type === "move" || type === "drag") {
+      pressRelease = "m"
+    }
+
+    return `\x1b[<${buttonCode};${ansiX};${ansiY}${pressRelease}`
+  }
+
+  const emitMouseEvent = async (
+    type: MouseEventType,
+    x: number,
+    y: number,
+    button: MouseButton = MouseButtons.LEFT,
+    options: Omit<MouseEventOptions, "button"> = {},
+  ): Promise<void> => {
+    const { modifiers = {}, delayMs = 0 } = options
+
+    const eventSequence = generateMouseEvent(type, x, y, button, modifiers)
+    renderer.stdin.emit("data", Buffer.from(eventSequence))
+
+    currentPosition = { x, y }
+
+    if (type === "down" && button < 64) {
+      buttonsPressed.add(button)
+    } else if (type === "up") {
+      buttonsPressed.delete(button)
+    }
+
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs))
+    }
+  }
+
+  const moveTo = async (x: number, y: number, options: MouseEventOptions = {}): Promise<void> => {
+    const { button = MouseButtons.LEFT, delayMs = 0, modifiers = {} } = options
+
+    if (buttonsPressed.size > 0) {
+      await emitMouseEvent("drag", x, y, Array.from(buttonsPressed)[0], { modifiers, delayMs })
+    } else {
+      await emitMouseEvent("move", x, y, button, { modifiers, delayMs })
+    }
+
+    currentPosition = { x, y }
+  }
+
+  const click = async (
+    x: number,
+    y: number,
+    button: MouseButton = MouseButtons.LEFT,
+    options: MouseEventOptions = {},
+  ): Promise<void> => {
+    const { delayMs = 10, modifiers = {} } = options
+
+    await emitMouseEvent("down", x, y, button, { modifiers, delayMs })
+    await new Promise((resolve) => setTimeout(resolve, delayMs))
+    await emitMouseEvent("up", x, y, button, { modifiers, delayMs })
+  }
+
+  const doubleClick = async (
+    x: number,
+    y: number,
+    button: MouseButton = MouseButtons.LEFT,
+    options: MouseEventOptions = {},
+  ): Promise<void> => {
+    const { delayMs = 10, modifiers = {} } = options
+
+    await click(x, y, button, { modifiers, delayMs })
+    await new Promise((resolve) => setTimeout(resolve, delayMs))
+    await click(x, y, button, { modifiers, delayMs })
+  }
+
+  const pressDown = async (
+    x: number,
+    y: number,
+    button: MouseButton = MouseButtons.LEFT,
+    options: MouseEventOptions = {},
+  ): Promise<void> => {
+    const { modifiers = {}, delayMs = 0 } = options
+    await emitMouseEvent("down", x, y, button, { modifiers, delayMs })
+  }
+
+  const release = async (
+    x: number,
+    y: number,
+    button: MouseButton = MouseButtons.LEFT,
+    options: MouseEventOptions = {},
+  ): Promise<void> => {
+    const { modifiers = {}, delayMs = 0 } = options
+    await emitMouseEvent("up", x, y, button, { modifiers, delayMs })
+  }
+
+  const drag = async (
+    startX: number,
+    startY: number,
+    endX: number,
+    endY: number,
+    button: MouseButton = MouseButtons.LEFT,
+    options: MouseEventOptions = {},
+  ): Promise<void> => {
+    const { delayMs = 10, modifiers = {} } = options
+
+    await pressDown(startX, startY, button, { modifiers })
+
+    const steps = 5
+    const dx = (endX - startX) / steps
+    const dy = (endY - startY) / steps
+
+    for (let i = 1; i <= steps; i++) {
+      const currentX = Math.round(startX + dx * i)
+      const currentY = Math.round(startY + dy * i)
+      await emitMouseEvent("drag", currentX, currentY, button, { modifiers, delayMs })
+    }
+
+    await release(endX, endY, button, { modifiers })
+  }
+
+  const scroll = async (
+    x: number,
+    y: number,
+    direction: "up" | "down" | "left" | "right",
+    options: MouseEventOptions = {},
+  ): Promise<void> => {
+    const { modifiers = {}, delayMs = 0 } = options
+
+    let button: MouseButton
+    switch (direction) {
+      case "up":
+        button = MouseButtons.WHEEL_UP
+        break
+      case "down":
+        button = MouseButtons.WHEEL_DOWN
+        break
+      case "left":
+        button = MouseButtons.WHEEL_LEFT
+        break
+      case "right":
+        button = MouseButtons.WHEEL_RIGHT
+        break
+    }
+
+    await emitMouseEvent("scroll", x, y, button, { modifiers, delayMs })
+  }
+
+  const getCurrentPosition = (): MousePosition => {
+    return { ...currentPosition }
+  }
+
+  const getPressedButtons = (): MouseButton[] => {
+    return Array.from(buttonsPressed)
+  }
+
+  return {
+    // Core interaction methods
+    moveTo,
+    click,
+    doubleClick,
+    pressDown,
+    release,
+    drag,
+    scroll,
+
+    // State getters
+    getCurrentPosition,
+    getPressedButtons,
+
+    // Low-level event emission (for advanced use cases)
+    emitMouseEvent,
+  }
+}

package/src/testing/mock-tree-sitter-client.ts

@@ -0,0 +1,81 @@
+import { TreeSitterClient } from "../lib/tree-sitter/index.js"
+import { SystemClock, type Clock, type TimerHandle } from "../lib/clock.js"
+import type { SimpleHighlight } from "../lib/tree-sitter/types.js"
+
+export class MockTreeSitterClient extends TreeSitterClient {
+  private _highlightPromises: Array<{
+    promise: Promise<{ highlights?: SimpleHighlight[]; warning?: string; error?: string }>
+    resolve: (result: { highlights?: SimpleHighlight[]; warning?: string; error?: string }) => void
+    timeout?: TimerHandle
+  }> = []
+  private _mockResult: { highlights?: SimpleHighlight[]; warning?: string; error?: string } = { highlights: [] }
+  private _autoResolveTimeout?: number
+  private readonly _clock: Clock
+
+  constructor(options?: { autoResolveTimeout?: number; clock?: Clock }) {
+    super({ dataPath: "/tmp/mock" }, { autoStartWorker: false })
+    this._autoResolveTimeout = options?.autoResolveTimeout
+    this._clock = options?.clock ?? new SystemClock()
+  }
+
+  override async destroy(): Promise<void> {
+    this.resolveAllHighlightOnce()
+    await super.destroy()
+  }
+
+  async highlightOnce(
+    content: string,
+    filetype: string,
+  ): Promise<{ highlights?: SimpleHighlight[]; warning?: string; error?: string }> {
+    const { promise, resolve } = Promise.withResolvers<{
+      highlights?: SimpleHighlight[]
+      warning?: string
+      error?: string
+    }>()
+
+    let timeout: TimerHandle | undefined
+
+    if (this._autoResolveTimeout !== undefined) {
+      timeout = this._clock.setTimeout(() => {
+        const index = this._highlightPromises.findIndex((p) => p.promise === promise)
+        if (index !== -1) {
+          resolve(this._mockResult)
+          this._highlightPromises.splice(index, 1)
+        }
+      }, this._autoResolveTimeout)
+    }
+
+    this._highlightPromises.push({ promise, resolve, timeout })
+
+    return promise
+  }
+
+  setMockResult(result: { highlights?: SimpleHighlight[]; warning?: string; error?: string }) {
+    this._mockResult = result
+  }
+
+  resolveHighlightOnce(index: number = 0) {
+    if (index >= 0 && index < this._highlightPromises.length) {
+      const item = this._highlightPromises[index]
+      if (item.timeout) {
+        this._clock.clearTimeout(item.timeout)
+      }
+      item.resolve(this._mockResult)
+      this._highlightPromises.splice(index, 1)
+    }
+  }
+
+  resolveAllHighlightOnce() {
+    for (const { resolve, timeout } of this._highlightPromises) {
+      if (timeout) {
+        this._clock.clearTimeout(timeout)
+      }
+      resolve(this._mockResult)
+    }
+    this._highlightPromises = []
+  }
+
+  isHighlighting(): boolean {
+    return this._highlightPromises.length > 0
+  }
+}

package/src/testing/spy.ts

@@ -0,0 +1,13 @@
+export function createSpy() {
+  const calls: any[][] = []
+  const spy = (...args: any[]) => {
+    calls.push(args)
+  }
+  spy.calls = calls
+  spy.callCount = () => calls.length
+  spy.calledWith = (...expected: any[]) => {
+    return calls.some((call) => JSON.stringify(call) === JSON.stringify(expected))
+  }
+  spy.reset = () => (calls.length = 0)
+  return spy
+}

package/src/testing/terminal-capabilities.ts

@@ -0,0 +1,47 @@
+import type { CliRenderer } from "../renderer.js"
+import type { TerminalCapabilities, TerminalInfo } from "../types.js"
+
+export interface TerminalCapabilitiesOverrides extends Partial<Omit<TerminalCapabilities, "terminal">> {
+  terminal?: Partial<TerminalInfo>
+}
+
+export function createTerminalCapabilities(overrides: TerminalCapabilitiesOverrides = {}): TerminalCapabilities {
+  return {
+    kitty_keyboard: false,
+    kitty_graphics: false,
+    rgb: false,
+    ansi256: false,
+    unicode: "unicode",
+    sgr_pixels: false,
+    color_scheme_updates: false,
+    explicit_width: false,
+    scaled_text: false,
+    sixel: false,
+    focus_tracking: false,
+    sync: false,
+    bracketed_paste: false,
+    hyperlinks: false,
+    osc52: false,
+    osc52_support: "unknown",
+    notifications: false,
+    explicit_cursor_positioning: false,
+    remote: false,
+    multiplexer: "none",
+    ...overrides,
+    terminal: {
+      name: "",
+      version: "",
+      from_xtversion: false,
+      ...overrides.terminal,
+    },
+  }
+}
+
+export function setRendererCapabilities(
+  renderer: CliRenderer,
+  overrides: TerminalCapabilitiesOverrides = {},
+): TerminalCapabilities {
+  const capabilities = createTerminalCapabilities(overrides)
+  ;(renderer as unknown as { _capabilities: TerminalCapabilities })._capabilities = capabilities
+  return capabilities
+}