@fairyhunter13/opentui-core 0.1.112 → 0.1.114

package/src/testing/mock-keys.ts

@@ -0,0 +1,457 @@
+import { Buffer } from "node:buffer"
+import type { CliRenderer } from "../renderer.js"
+import { ANSI } from "../ansi.js"
+
+export function pasteBytes(text: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(text))
+}
+
+export const KeyCodes = {
+  // Control keys
+  RETURN: "\r",
+  LINEFEED: "\n",
+  TAB: "\t",
+  BACKSPACE: "\b",
+  // NOTE: This may depend on the platform and terminals
+  DELETE: "\x1b[3~",
+  HOME: "\x1b[H",
+  END: "\x1b[F",
+  ESCAPE: "\x1b",
+
+  // Arrow keys
+  ARROW_UP: "\x1b[A",
+  ARROW_DOWN: "\x1b[B",
+  ARROW_RIGHT: "\x1b[C",
+  ARROW_LEFT: "\x1b[D",
+
+  // Function keys
+  F1: "\x1bOP",
+  F2: "\x1bOQ",
+  F3: "\x1bOR",
+  F4: "\x1bOS",
+  F5: "\x1b[15~",
+  F6: "\x1b[17~",
+  F7: "\x1b[18~",
+  F8: "\x1b[19~",
+  F9: "\x1b[20~",
+  F10: "\x1b[21~",
+  F11: "\x1b[23~",
+  F12: "\x1b[24~",
+} as const
+
+export type KeyInput = string | keyof typeof KeyCodes
+
+export interface MockKeysOptions {
+  kittyKeyboard?: boolean
+  otherModifiersMode?: boolean
+}
+
+// Kitty keyboard protocol key mappings
+const kittyKeyCodeMap: Record<string, number> = {
+  escape: 27,
+  tab: 9,
+  return: 13,
+  backspace: 127,
+  insert: 57348,
+  delete: 57349,
+  left: 57350,
+  right: 57351,
+  up: 57352,
+  down: 57353,
+  pageup: 57354,
+  pagedown: 57355,
+  home: 57356,
+  end: 57357,
+  f1: 57364,
+  f2: 57365,
+  f3: 57366,
+  f4: 57367,
+  f5: 57368,
+  f6: 57369,
+  f7: 57370,
+  f8: 57371,
+  f9: 57372,
+  f10: 57373,
+  f11: 57374,
+  f12: 57375,
+}
+
+function encodeKittySequence(
+  codepoint: number,
+  modifiers?: { shift?: boolean; ctrl?: boolean; meta?: boolean; super?: boolean; hyper?: boolean },
+): string {
+  // Kitty keyboard protocol: CSI unicode-key-code ; modifiers u
+  // Modifier encoding: shift=1, alt=2, ctrl=4, super=8, hyper=16, meta=32, caps=64, num=128
+  let modMask = 0
+  if (modifiers?.shift) modMask |= 1
+  if (modifiers?.meta) modMask |= 2 // alt/meta
+  if (modifiers?.ctrl) modMask |= 4
+  if (modifiers?.super) modMask |= 8
+  if (modifiers?.hyper) modMask |= 16
+
+  if (modMask === 0) {
+    // No modifiers
+    return `\x1b[${codepoint}u`
+  } else {
+    // With modifiers (kitty uses 1-based, so add 1)
+    return `\x1b[${codepoint};${modMask + 1}u`
+  }
+}
+
+function encodeModifyOtherKeysSequence(
+  charCode: number,
+  modifiers?: { shift?: boolean; ctrl?: boolean; meta?: boolean; super?: boolean; hyper?: boolean },
+): string {
+  // modifyOtherKeys protocol: CSI 27 ; modifier ; code ~
+  // This is the format used by xterm, iTerm2, Ghostty with modifyOtherKeys enabled
+  // Modifier encoding: shift=1, alt/option=2, ctrl=4, super=8, hyper=16 (1-based, so add 1)
+  let modMask = 0
+  if (modifiers?.shift) modMask |= 1
+  if (modifiers?.meta) modMask |= 2 // alt/option/meta
+  if (modifiers?.ctrl) modMask |= 4
+  if (modifiers?.super) modMask |= 8
+  if (modifiers?.hyper) modMask |= 16
+
+  // modifyOtherKeys is only used when modifiers are present
+  // Without modifiers, use the standard key sequence
+  if (modMask === 0) {
+    return String.fromCharCode(charCode)
+  }
+
+  // With modifiers, use CSI 27 ; modifier ; code ~
+  return `\x1b[27;${modMask + 1};${charCode}~`
+}
+
+interface ResolvedKey {
+  keyValue: string
+  keyName: string | undefined
+}
+
+function resolveKeyInput(key: KeyInput): ResolvedKey {
+  let keyValue: string
+  let keyName: string | undefined
+
+  if (typeof key === "string") {
+    if (key in KeyCodes) {
+      // It's a KeyCode name like "BACKSPACE", "ARROW_UP", etc.
+      keyValue = KeyCodes[key as keyof typeof KeyCodes]
+      keyName = key.toLowerCase()
+    } else {
+      // It's a regular character
+      keyValue = key
+      keyName = undefined
+    }
+  } else {
+    // It's already a keycode enum value
+    keyValue = KeyCodes[key]
+    if (!keyValue) {
+      throw new Error(`Unknown key: ${key}`)
+    }
+    keyName = String(key).toLowerCase()
+  }
+
+  return { keyValue, keyName }
+}
+
+export function createMockKeys(renderer: CliRenderer, options?: MockKeysOptions) {
+  const useKittyKeyboard = options?.kittyKeyboard ?? false
+  const useOtherModifiersMode = options?.otherModifiersMode ?? false
+
+  // Kitty keyboard takes precedence over otherModifiersMode
+  const effectiveOtherModifiersMode = useOtherModifiersMode && !useKittyKeyboard
+
+  const pressKeys = async (keys: KeyInput[], delayMs: number = 0): Promise<void> => {
+    for (const key of keys) {
+      const { keyValue: keyCode } = resolveKeyInput(key)
+
+      renderer.stdin.emit("data", Buffer.from(keyCode))
+
+      if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs))
+      }
+    }
+  }
+
+  const pressKey = (
+    key: KeyInput,
+    modifiers?: { shift?: boolean; ctrl?: boolean; meta?: boolean; super?: boolean; hyper?: boolean },
+  ): void => {
+    // Handle Kitty keyboard protocol mode
+    if (useKittyKeyboard) {
+      // Resolve the key to its string representation or keycode value
+      let { keyValue, keyName } = resolveKeyInput(key)
+
+      // Map control characters and escape sequences to their kitty key names
+      const valueToKeyNameMap: Record<string, string> = {
+        "\b": "backspace",
+        "\r": "return",
+        "\n": "return",
+        "\t": "tab",
+        "\x1b": "escape",
+        "\x1b[A": "up",
+        "\x1b[B": "down",
+        "\x1b[C": "right",
+        "\x1b[D": "left",
+        "\x1b[H": "home",
+        "\x1b[F": "end",
+        "\x1b[3~": "delete",
+      }
+
+      // Check value mapping
+      if (keyValue && valueToKeyNameMap[keyValue]) {
+        keyName = valueToKeyNameMap[keyValue]
+      }
+
+      // Also check for ARROW_ prefix
+      if (keyName && keyName.startsWith("arrow_")) {
+        keyName = keyName.substring(6) // Remove "arrow_" prefix
+      }
+
+      // Check if we have a direct kitty code mapping
+      if (keyName && kittyKeyCodeMap[keyName]) {
+        const kittyCode = kittyKeyCodeMap[keyName]
+        const sequence = encodeKittySequence(kittyCode, modifiers)
+        renderer.stdin.emit("data", Buffer.from(sequence))
+        return
+      }
+
+      // For regular characters, get the codepoint
+      if (keyValue && keyValue.length === 1 && !keyValue.startsWith("\x1b")) {
+        const codepoint = keyValue.codePointAt(0)
+        if (codepoint) {
+          const sequence = encodeKittySequence(codepoint, modifiers)
+          renderer.stdin.emit("data", Buffer.from(sequence))
+          return
+        }
+      }
+
+      // Fall through to regular mode for unknown keys
+    }
+
+    // Handle modifyOtherKeys mode (CSI u protocol variant)
+    // Used by xterm, iTerm2, Ghostty with modifyOtherKeys enabled
+    if (effectiveOtherModifiersMode && modifiers) {
+      // Resolve the key to its string representation or keycode value
+      let { keyValue, keyName } = resolveKeyInput(key)
+
+      // Map control characters and escape sequences to their char codes
+      const valueToCharCodeMap: Record<string, number> = {
+        "\b": 127, // backspace (or 8, but 127 is more common)
+        "\r": 13, // return
+        "\n": 13, // linefeed -> return
+        "\t": 9, // tab
+        "\x1b": 27, // escape
+        " ": 32, // space
+      }
+
+      // Check if we have a control character that needs modifyOtherKeys encoding
+      let charCode: number | undefined
+
+      if (keyValue && valueToCharCodeMap[keyValue] !== undefined) {
+        charCode = valueToCharCodeMap[keyValue]
+      } else if (keyValue && keyValue.length === 1 && !keyValue.startsWith("\x1b")) {
+        // For regular single characters
+        charCode = keyValue.charCodeAt(0)
+      }
+
+      // If we have a char code and modifiers, use modifyOtherKeys format
+      if (charCode !== undefined) {
+        const sequence = encodeModifyOtherKeysSequence(charCode, modifiers)
+        renderer.stdin.emit("data", Buffer.from(sequence))
+        return
+      }
+
+      // For other keys (like arrow keys with modifiers), fall through to regular mode
+    }
+
+    // Regular (non-Kitty, non-modifyOtherKeys) mode
+    let keyCode = resolveKeyInput(key).keyValue
+
+    // Apply modifiers if present
+    if (modifiers) {
+      // For arrow keys and special keys, modify the escape sequence
+      if (keyCode.startsWith("\x1b[") && keyCode.length > 2) {
+        // Arrow keys: \x1b[A, \x1b[B, \x1b[C, \x1b[D
+        // With shift modifier: \x1b[1;2A, \x1b[1;2B, \x1b[1;2C, \x1b[1;2D
+        // Special keys like delete: \x1b[3~ becomes \x1b[3;2~ with meta
+        const modifier =
+          1 +
+          (modifiers.shift ? 1 : 0) +
+          (modifiers.meta ? 2 : 0) +
+          (modifiers.ctrl ? 4 : 0) +
+          (modifiers.super ? 8 : 0) +
+          (modifiers.hyper ? 16 : 0)
+        if (modifier > 1) {
+          // Check if it's a sequence like \x1b[3~ (delete, insert, pageup, etc.)
+          const tildeMatch = keyCode.match(/^\x1b\[(\d+)~$/)
+          if (tildeMatch) {
+            // Format: \x1b[number;modifier~
+            keyCode = `\x1b[${tildeMatch[1]};${modifier}~`
+          } else {
+            // Arrow keys and other single-letter endings
+            // Insert modifier into sequence
+            const ending = keyCode.slice(-1)
+            keyCode = `\x1b[1;${modifier}${ending}`
+          }
+        }
+      } else if (keyCode.length === 1) {
+        // For regular characters and single-char control codes with modifiers
+        let char = keyCode
+
+        // Shift+Tab produces the back-tab escape sequence \x1b[Z in standard ANSI terminals
+        if (char === "\t" && modifiers.shift) {
+          // Build the base as \x1b[Z, then apply meta prefix if also pressed
+          keyCode = modifiers.meta ? "\x1b\x1b[Z" : "\x1b[Z"
+          renderer.stdin.emit("data", Buffer.from(keyCode))
+          return
+        }
+
+        // Special handling for backspace with modifiers - use modifyOtherKeys format
+        // Terminals send Ctrl+Backspace as CSI 27;5;127~ (or CSI 27;5;8~)
+        // Only use modifyOtherKeys for ctrl, super, or hyper (not shift or meta alone)
+        if (char === "\b" && (modifiers.ctrl || modifiers.super || modifiers.hyper)) {
+          const modifier =
+            1 +
+            (modifiers.shift ? 1 : 0) +
+            (modifiers.meta ? 2 : 0) +
+            (modifiers.ctrl ? 4 : 0) +
+            (modifiers.super ? 8 : 0) +
+            (modifiers.hyper ? 16 : 0)
+          // Use charcode 127 for backspace (DEL)
+          keyCode = `\x1b[27;${modifier};127~`
+        } else if (modifiers.ctrl) {
+          // Handle ctrl modifier for characters
+          // Ctrl+letter produces control codes (0x01-0x1a for a-z)
+          if (char >= "a" && char <= "z") {
+            keyCode = String.fromCharCode(char.charCodeAt(0) - 96)
+          } else if (char >= "A" && char <= "Z") {
+            keyCode = String.fromCharCode(char.charCodeAt(0) - 64)
+          } else {
+            // Handle special characters with ctrl modifier
+            // These produce ASCII control codes
+            const specialCtrlMap: Record<string, string> = {
+              "[": "\x1b", // Ctrl+[ = ESC (ASCII 27)
+              "\\": "\x1c", // Ctrl+\ = FS (ASCII 28)
+              "]": "\x1d", // Ctrl+] = GS (ASCII 29)
+              "^": "\x1e", // Ctrl+^ = RS (ASCII 30)
+              _: "\x1f", // Ctrl+_ = US (ASCII 31)
+              "?": "\x7f", // Ctrl+? = DEL (ASCII 127)
+              // Common aliases
+              "/": "\x1f", // Ctrl+/ = US (ASCII 31, same as Ctrl+_)
+              "-": "\x1f", // Ctrl+- = US (ASCII 31, same as Ctrl+_)
+              ".": "\x1e", // Ctrl+. = RS (ASCII 30, same as Ctrl+^)
+              ",": "\x1c", // Ctrl+, = FS (ASCII 28, same as Ctrl+\)
+              "@": "\x00", // Ctrl+@ = NUL (ASCII 0)
+              " ": "\x00", // Ctrl+Space = NUL (ASCII 0)
+            }
+
+            if (char in specialCtrlMap) {
+              keyCode = specialCtrlMap[char]
+            }
+            // If no mapping found, keep the original character
+          }
+          // If meta is also pressed, prefix with escape
+          if (modifiers.meta) {
+            keyCode = `\x1b${keyCode}`
+          }
+        } else {
+          // Handle shift+meta or just meta
+          if (modifiers.shift && char >= "a" && char <= "z") {
+            char = char.toUpperCase()
+          }
+          if (modifiers.meta) {
+            // For meta+character (including control codes), prefix with escape
+            keyCode = `\x1b${char}`
+          } else {
+            keyCode = char
+          }
+        }
+      } else if (modifiers.meta && !keyCode.startsWith("\x1b")) {
+        // For multi-char sequences that aren't escape sequences (like simple control codes)
+        // just prefix with escape for meta
+        keyCode = `\x1b${keyCode}`
+      }
+    }
+
+    renderer.stdin.emit("data", Buffer.from(keyCode))
+  }
+
+  const typeText = async (text: string, delayMs: number = 0): Promise<void> => {
+    const keys = text.split("")
+    await pressKeys(keys, delayMs)
+  }
+
+  const pressReturn = (modifiers?: {
+    shift?: boolean
+    ctrl?: boolean
+    meta?: boolean
+    super?: boolean
+    hyper?: boolean
+  }): void => {
+    pressKey(KeyCodes.RETURN, modifiers)
+  }
+
+  const pressEscape = (modifiers?: {
+    shift?: boolean
+    ctrl?: boolean
+    meta?: boolean
+    super?: boolean
+    hyper?: boolean
+  }): void => {
+    pressKey(KeyCodes.ESCAPE, modifiers)
+  }
+
+  const pressTab = (modifiers?: {
+    shift?: boolean
+    ctrl?: boolean
+    meta?: boolean
+    super?: boolean
+    hyper?: boolean
+  }): void => {
+    pressKey(KeyCodes.TAB, modifiers)
+  }
+
+  const pressBackspace = (modifiers?: {
+    shift?: boolean
+    ctrl?: boolean
+    meta?: boolean
+    super?: boolean
+    hyper?: boolean
+  }): void => {
+    pressKey(KeyCodes.BACKSPACE, modifiers)
+  }
+
+  const pressArrow = (
+    direction: "up" | "down" | "left" | "right",
+    modifiers?: { shift?: boolean; ctrl?: boolean; meta?: boolean; super?: boolean; hyper?: boolean },
+  ): void => {
+    const keyMap = {
+      up: KeyCodes.ARROW_UP,
+      down: KeyCodes.ARROW_DOWN,
+      left: KeyCodes.ARROW_LEFT,
+      right: KeyCodes.ARROW_RIGHT,
+    }
+    pressKey(keyMap[direction], modifiers)
+  }
+
+  const pressCtrlC = (): void => {
+    pressKey("c", { ctrl: true })
+  }
+
+  const pasteBracketedText = (text: string): Promise<void> => {
+    return pressKeys([ANSI.bracketedPasteStart, text, ANSI.bracketedPasteEnd])
+  }
+
+  return {
+    pressKeys,
+    pressKey,
+    typeText,
+    pressEnter: pressReturn,
+    pressEscape,
+    pressTab,
+    pressBackspace,
+    pressArrow,
+    pressCtrlC,
+    pasteBracketedText,
+  }
+}

package/src/testing/mock-mouse.test.ts

@@ -0,0 +1,218 @@
+import { describe, test, expect } from "bun:test"
+import { createMockMouse, MouseButtons } from "./mock-mouse.js"
+import { PassThrough } from "stream"
+
+class MockRenderer {
+  public stdin: PassThrough
+  public emittedData: Buffer[] = []
+
+  constructor() {
+    this.stdin = new PassThrough()
+
+    this.stdin.on("data", (chunk: Buffer) => {
+      this.emittedData.push(chunk)
+    })
+  }
+
+  getEmittedData(): string {
+    return Buffer.concat(this.emittedData).toString()
+  }
+
+  getLastEmittedData(): string {
+    return this.emittedData.length > 0 ? this.emittedData[this.emittedData.length - 1].toString() : ""
+  }
+}
+
+describe("mock-mouse", () => {
+  test("click generates correct mouse events", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.click(10, 5)
+
+    expect(mockRenderer.emittedData).toHaveLength(2)
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<0;11;6M") // down event
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<0;11;6m") // up event
+  })
+
+  test("click with different button", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.click(10, 5, MouseButtons.RIGHT)
+
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<2;11;6M") // right button down
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<2;11;6m") // right button up
+  })
+
+  test("click with modifiers", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.click(10, 5, MouseButtons.LEFT, { modifiers: { ctrl: true, shift: true } })
+
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<20;11;6M") // 0 + 16 (ctrl) + 4 (shift) = 20
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<20;11;6m")
+  })
+
+  test("moveTo generates move event", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.moveTo(15, 8)
+
+    expect(mockRenderer.getEmittedData()).toBe("\x1b[<35;16;9m") // 32 (motion) + 3 (button 3 for move) = 35
+  })
+
+  test("moveTo with modifiers", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.moveTo(15, 8, { modifiers: { alt: true } })
+
+    expect(mockRenderer.getEmittedData()).toBe("\x1b[<43;16;9m") // 32 + 3 + 8 (alt) = 43
+  })
+
+  test("doubleClick generates four events", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.doubleClick(10, 5)
+
+    expect(mockRenderer.emittedData).toHaveLength(4)
+    // Two down events and two up events
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<0;11;6M")
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<0;11;6m")
+    expect(mockRenderer.emittedData[2].toString()).toBe("\x1b[<0;11;6M")
+    expect(mockRenderer.emittedData[3].toString()).toBe("\x1b[<0;11;6m")
+  })
+
+  test("pressDown and release work separately", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.pressDown(10, 5, MouseButtons.MIDDLE)
+    await mockMouse.release(10, 5, MouseButtons.MIDDLE)
+
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<1;11;6M") // middle button down
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<1;11;6m") // middle button up
+  })
+
+  test("drag generates drag events", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.drag(10, 5, 20, 10)
+
+    // Should have: down, several drag events, up
+    expect(mockRenderer.emittedData.length).toBeGreaterThan(3)
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<0;11;6M") // initial down
+
+    // Check that drag events have the motion flag (32)
+    for (let i = 1; i < mockRenderer.emittedData.length - 1; i++) {
+      const event = mockRenderer.emittedData[i].toString()
+      expect(event).toMatch(/\x1b\[<32;\d+;\d+m/) // Should have motion flag (32) and release (m)
+    }
+
+    const lastEvent = mockRenderer.emittedData[mockRenderer.emittedData.length - 1].toString()
+    expect(lastEvent).toBe("\x1b[<0;21;11m") // final up
+  })
+
+  test("scroll events work", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.scroll(10, 5, "up")
+    await mockMouse.scroll(10, 5, "down")
+
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<64;11;6M") // wheel up (64 = scroll flag)
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<65;11;6M") // wheel down (64 + 1)
+  })
+
+  test("scroll with modifiers", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.scroll(10, 5, "left", { modifiers: { shift: true } })
+
+    expect(mockRenderer.getEmittedData()).toBe("\x1b[<70;11;6M") // 66 (wheel left) + 4 (shift) = 70
+  })
+
+  test("moveTo becomes drag when button is pressed", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.pressDown(5, 5)
+    await mockMouse.moveTo(15, 8)
+
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<0;6;6M") // down
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<32;16;9m") // drag (32 = motion flag, no button 3)
+  })
+
+  test("getCurrentPosition tracks position", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    expect(mockMouse.getCurrentPosition()).toEqual({ x: 0, y: 0 })
+
+    await mockMouse.moveTo(10, 5)
+    expect(mockMouse.getCurrentPosition()).toEqual({ x: 10, y: 5 })
+
+    await mockMouse.click(15, 8)
+    expect(mockMouse.getCurrentPosition()).toEqual({ x: 15, y: 8 })
+  })
+
+  test("getPressedButtons tracks button state", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    expect(mockMouse.getPressedButtons()).toEqual([])
+
+    await mockMouse.pressDown(10, 5, MouseButtons.LEFT)
+    expect(mockMouse.getPressedButtons()).toEqual([MouseButtons.LEFT])
+
+    await mockMouse.pressDown(10, 5, MouseButtons.RIGHT)
+    expect(mockMouse.getPressedButtons()).toEqual([MouseButtons.LEFT, MouseButtons.RIGHT])
+
+    await mockMouse.release(10, 5, MouseButtons.LEFT)
+    expect(mockMouse.getPressedButtons()).toEqual([MouseButtons.RIGHT])
+
+    await mockMouse.release(10, 5, MouseButtons.RIGHT)
+    expect(mockMouse.getPressedButtons()).toEqual([])
+  })
+
+  test("delay works correctly", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    const startTime = Date.now()
+    await mockMouse.click(10, 5, MouseButtons.LEFT, { delayMs: 20 })
+
+    expect(Date.now() - startTime).toBeGreaterThanOrEqual(15) // Allow some tolerance
+  })
+
+  test("coordinates are 1-based in ANSI output", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.click(0, 0) // 0-based coordinates
+
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<0;1;1M") // 1-based in ANSI
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<0;1;1m")
+  })
+
+  test("all scroll directions work", async () => {
+    const mockRenderer = new MockRenderer()
+    const mockMouse = createMockMouse(mockRenderer as any)
+
+    await mockMouse.scroll(10, 5, "up")
+    await mockMouse.scroll(10, 5, "down")
+    await mockMouse.scroll(10, 5, "left")
+    await mockMouse.scroll(10, 5, "right")
+
+    expect(mockRenderer.emittedData[0].toString()).toBe("\x1b[<64;11;6M") // up
+    expect(mockRenderer.emittedData[1].toString()).toBe("\x1b[<65;11;6M") // down
+    expect(mockRenderer.emittedData[2].toString()).toBe("\x1b[<66;11;6M") // left
+    expect(mockRenderer.emittedData[3].toString()).toBe("\x1b[<67;11;6M") // right
+  })
+})