@fairyhunter13/opentui-core 0.1.114 → 0.1.116

package/src/testing/integration.test.ts

@@ -1,276 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { createMockMouse, MouseButtons } from "./mock-mouse.js"
-import { MouseParser } from "../lib/parse.mouse.js"
-
-class MockRenderer {
-  public stdin: { emit: (event: string, data: Buffer) => void }
-  public emittedData: Buffer[] = []
-
-  constructor() {
-    this.stdin = {
-      emit: (event: string, chunk: Buffer) => {
-        this.emittedData.push(chunk)
-      },
-    }
-  }
-
-  getEmittedData(): Buffer {
-    return Buffer.concat(this.emittedData)
-  }
-}
-
-// Helper function to parse all events from buffer
-function parseAllEvents(emittedData: Buffer, parser: MouseParser) {
-  return parser.parseAllMouseEvents(emittedData)
-}
-
-describe("mock-mouse + parser integration", () => {
-  test("simple click is correctly parsed", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.click(10, 5)
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(2)
-    expect(parsedEvents[0]).toEqual({
-      type: "down",
-      button: 0,
-      x: 10,
-      y: 5,
-      modifiers: { shift: false, alt: false, ctrl: false },
-      scroll: undefined,
-    })
-    expect(parsedEvents[1]).toEqual({
-      type: "up",
-      button: 0,
-      x: 10,
-      y: 5,
-      modifiers: { shift: false, alt: false, ctrl: false },
-      scroll: undefined,
-    })
-  })
-
-  test("double click is correctly parsed", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.doubleClick(10, 5)
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(4)
-    // All events should be at the same position with LEFT button
-    parsedEvents.forEach((event) => {
-      expect(event.x).toBe(10)
-      expect(event.y).toBe(5)
-      expect(event.button).toBe(0)
-    })
-    // Should alternate down/up
-    expect(parsedEvents.map((e) => e.type)).toEqual(["down", "up", "down", "up"])
-  })
-
-  test("pressDown and release separately are correctly parsed", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.pressDown(10, 5, MouseButtons.MIDDLE)
-    await mockMouse.release(10, 5, MouseButtons.MIDDLE)
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(2)
-    expect(parsedEvents[0]).toEqual({
-      type: "down",
-      button: 1, // MIDDLE button
-      x: 10,
-      y: 5,
-      modifiers: { shift: false, alt: false, ctrl: false },
-      scroll: undefined,
-    })
-    expect(parsedEvents[1]).toEqual({
-      type: "up",
-      button: 1,
-      x: 10,
-      y: 5,
-      modifiers: { shift: false, alt: false, ctrl: false },
-      scroll: undefined,
-    })
-  })
-
-  test("different buttons work correctly", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    // Test RIGHT button
-    await mockMouse.click(10, 5, MouseButtons.RIGHT)
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(2)
-    parsedEvents.forEach((event) => {
-      expect(event.button).toBe(2) // RIGHT button
-      expect(event.x).toBe(10)
-      expect(event.y).toBe(5)
-    })
-  })
-
-  test("all scroll directions are correctly parsed", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.scroll(15, 8, "up")
-    await mockMouse.scroll(15, 8, "down")
-    await mockMouse.scroll(15, 8, "left")
-    await mockMouse.scroll(15, 8, "right")
-
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(4)
-    const expectedDirections: ("up" | "down" | "left" | "right")[] = ["up", "down", "left", "right"]
-    const expectedButtons = [0, 1, 2, 0] // Based on parser logic: button & 3, with button=3 becoming 0
-    parsedEvents.forEach((event, index) => {
-      expect(event.type).toBe("scroll")
-      expect(event.button).toBe(expectedButtons[index])
-      expect(event.x).toBe(15)
-      expect(event.y).toBe(8)
-      expect(event.scroll).toEqual({
-        direction: expectedDirections[index],
-        delta: 1,
-      })
-    })
-  })
-
-  test("scroll with modifiers is correctly parsed", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.scroll(15, 8, "left", { modifiers: { shift: true } })
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(1)
-    expect(parsedEvents[0]).toEqual({
-      type: "scroll",
-      button: 2, // WHEEL_LEFT (66) & 3 = 2
-      x: 15,
-      y: 8,
-      modifiers: { shift: true, alt: false, ctrl: false },
-      scroll: { direction: "left", delta: 1 },
-    })
-  })
-
-  test("drag events are correctly parsed", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.drag(5, 5, 15, 10)
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    // Should have down, several drag events, and up
-    expect(parsedEvents.length).toBeGreaterThan(3)
-    expect(parsedEvents[0].type).toBe("down")
-    expect(parsedEvents[0].button).toBe(0)
-    expect(parsedEvents[0].x).toBe(5)
-    expect(parsedEvents[0].y).toBe(5)
-
-    // Check that intermediate events are drag events
-    for (let i = 1; i < parsedEvents.length - 1; i++) {
-      expect(parsedEvents[i].type).toBe("drag")
-      expect(parsedEvents[i].button).toBe(0)
-    }
-
-    const lastEvent = parsedEvents[parsedEvents.length - 1]
-    expect(lastEvent.type).toBe("up")
-    expect(lastEvent.x).toBe(15)
-    expect(lastEvent.y).toBe(10)
-  })
-
-  test("moveTo without button press generates move events", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.moveTo(15, 8)
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(1)
-    expect(parsedEvents[0]).toEqual({
-      type: "move",
-      button: 0,
-      x: 15,
-      y: 8,
-      modifiers: { shift: false, alt: false, ctrl: false },
-      scroll: undefined,
-    })
-  })
-
-  test("moveTo with button press generates drag events", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.pressDown(5, 5)
-    await mockMouse.moveTo(15, 8)
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents).toHaveLength(2)
-    expect(parsedEvents[0].type).toBe("down")
-    expect(parsedEvents[1].type).toBe("drag")
-    expect(parsedEvents[1].x).toBe(15)
-    expect(parsedEvents[1].y).toBe(8)
-  })
-
-  test("all modifier combinations work", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    const modifierCombos = [
-      { shift: true },
-      { alt: true },
-      { ctrl: true },
-      { shift: true, alt: true },
-      { shift: true, ctrl: true },
-      { alt: true, ctrl: true },
-      { shift: true, alt: true, ctrl: true },
-    ]
-
-    for (const modifiers of modifierCombos) {
-      const testRenderer = new MockRenderer()
-      const testMouse = createMockMouse(testRenderer as any)
-      const testParser = new MouseParser()
-
-      await testMouse.click(10, 5, MouseButtons.LEFT, { modifiers })
-      const parsedEvents = parseAllEvents(testRenderer.getEmittedData(), testParser)
-
-      expect(parsedEvents).toHaveLength(2)
-      parsedEvents.forEach((event) => {
-        expect(event.modifiers).toEqual({
-          ...modifiers,
-          shift: modifiers.shift || false,
-          alt: modifiers.alt || false,
-          ctrl: modifiers.ctrl || false,
-        })
-      })
-    }
-  })
-
-  test("drag with different button and modifiers", async () => {
-    const mockRenderer = new MockRenderer()
-    const mockMouse = createMockMouse(mockRenderer as any)
-    const parser = new MouseParser()
-
-    await mockMouse.drag(5, 5, 15, 10, MouseButtons.RIGHT, { modifiers: { alt: true } })
-    const parsedEvents = parseAllEvents(mockRenderer.getEmittedData(), parser)
-
-    expect(parsedEvents.length).toBeGreaterThan(3)
-    parsedEvents.forEach((event) => {
-      expect(event.button).toBe(2) // RIGHT button
-      expect(event.modifiers.alt).toBe(true)
-    })
-  })
-})

package/src/testing/manual-clock.ts

@@ -1,117 +0,0 @@
-import type { Clock, TimerHandle } from "../lib/clock.js"
-
-interface ScheduledTimer {
-  id: number
-  fireAt: number
-  order: number
-  delayMs: number
-  repeat: boolean
-  fn: () => void
-}
-
-function compareTimers(left: ScheduledTimer, right: ScheduledTimer): number {
-  if (left.fireAt !== right.fireAt) {
-    return left.fireAt - right.fireAt
-  }
-
-  return left.order - right.order
-}
-
-export class ManualClock implements Clock {
-  private time = 0
-  private nextId = 1
-  private nextOrder = 0
-  private readonly timers = new Map<number, ScheduledTimer>()
-
-  public now(): number {
-    return this.time
-  }
-
-  public setTime(time: number): void {
-    const targetTime = Math.floor(time)
-
-    if (targetTime >= this.time) {
-      this.advance(targetTime - this.time)
-      return
-    }
-
-    this.time = targetTime
-  }
-
-  public setTimeout(fn: () => void, delayMs: number): TimerHandle {
-    return this.schedule(fn, delayMs, false)
-  }
-
-  public clearTimeout(handle: TimerHandle): void {
-    this.timers.delete(Number(handle))
-  }
-
-  public setInterval(fn: () => void, delayMs: number): TimerHandle {
-    return this.schedule(fn, delayMs, true)
-  }
-
-  public clearInterval(handle: TimerHandle): void {
-    this.clearTimeout(handle)
-  }
-
-  public advance(delayMs: number): void {
-    const targetTime = this.time + Math.max(0, Math.floor(delayMs))
-
-    while (true) {
-      const nextTimer = this.peekNextTimer()
-      if (!nextTimer || nextTimer.fireAt > targetTime) {
-        break
-      }
-
-      this.timers.delete(nextTimer.id)
-      this.time = nextTimer.fireAt
-      nextTimer.fn()
-
-      if (nextTimer.repeat && !this.timers.has(nextTimer.id)) {
-        this.timers.set(nextTimer.id, {
-          ...nextTimer,
-          fireAt: this.time + nextTimer.delayMs,
-          order: this.nextOrder++,
-        })
-      }
-    }
-
-    this.time = targetTime
-  }
-
-  public runAll(): void {
-    while (true) {
-      const nextTimer = this.peekNextTimer()
-      if (!nextTimer) {
-        return
-      }
-
-      this.advance(nextTimer.fireAt - this.time)
-    }
-  }
-
-  private schedule(fn: () => void, delayMs: number, repeat: boolean): number {
-    const id = this.nextId++
-    const normalizedDelay = Math.max(0, Math.floor(delayMs))
-    this.timers.set(id, {
-      id,
-      fireAt: this.time + normalizedDelay,
-      order: this.nextOrder++,
-      delayMs: normalizedDelay,
-      repeat,
-      fn,
-    })
-    return id
-  }
-
-  private peekNextTimer(): ScheduledTimer | null {
-    let nextTimer: ScheduledTimer | null = null
-    for (const timer of this.timers.values()) {
-      if (!nextTimer || compareTimers(timer, nextTimer) < 0) {
-        nextTimer = timer
-      }
-    }
-
-    return nextTimer
-  }
-}