Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

6.6 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import {
  browserWheelDeltaFromScreen,
  clampBrowserZoomState,
  computeBrowserFrameGeometry,
  computeBrowserTouchClickRadiusCss,
  mapScreenToBrowserPoint,
  readLocalTouchPoint
} from './browser-touch-geometry'

const NO_ZOOM = { scale: 1, offsetX: 0, offsetY: 0 }

// Measured Chromium 1217 (2026-09-20): no-viewport-meta page lays out at 980 CSS px within 402×593 emulation, scale 402/980.
// CDP takes viewport-relative CSS coordinates: divide device by scale without scroll offsets, which overshot a scrolled target by 300px.
const NO_VIEWPORT_META = {
  deviceWidth: 402,
  deviceHeight: 593,
  pageScaleFactor: 0.41020408272743225,
  scrollOffsetX: 0,
  scrollOffsetY: 300
}

/** The fixture's alert button, in the page's own CSS pixels. */
const BUTTON = { left: 32, top: 112, right: 115, bottom: 162 }

describe('browser touch geometry', () => {
  it('maps the visual center of a letterboxed desktop frame to the browser center', () => {
    const layout = { width: 390, height: 700 }
    const metadata = { deviceWidth: 1280, deviceHeight: 720 }
    const geometry = computeBrowserFrameGeometry(layout, metadata)

    expect(geometry).toMatchObject({
      renderedWidth: 390,
      offsetX: 0,
      sourceWidth: 1280,
      sourceHeight: 720
    })
    expect(
      mapScreenToBrowserPoint(
        195,
        geometry!.offsetY + geometry!.renderedHeight / 2,
        layout,
        metadata,
        { scale: 1, offsetX: 0, offsetY: 0 }
      )
    ).toEqual({ x: 640, y: 360 })
  })

  it('inverts pan and zoom around the rendered frame center', () => {
    const layout = { width: 390, height: 700 }
    const metadata = { deviceWidth: 1280, deviceHeight: 720 }
    const geometry = computeBrowserFrameGeometry(layout, metadata)!
    const zoom = { scale: 2, offsetX: -48, offsetY: 32 }
    const browserPoint = { x: 960, y: 540 }
    const localX = (browserPoint.x / metadata.deviceWidth) * geometry.renderedWidth
    const localY = (browserPoint.y / metadata.deviceHeight) * geometry.renderedHeight
    const screenX =
      geometry.offsetX +
      geometry.renderedWidth / 2 +
      zoom.offsetX +
      (localX - geometry.renderedWidth / 2) * zoom.scale
    const screenY =
      geometry.offsetY +
      geometry.renderedHeight / 2 +
      zoom.offsetY +
      (localY - geometry.renderedHeight / 2) * zoom.scale

    expect(mapScreenToBrowserPoint(screenX, screenY, layout, metadata, zoom)).toEqual(browserPoint)
  })

  it('maps a tap on a page with no viewport meta into the page CSS pixels', () => {
    const layout = { width: 402, height: 593 }
    const scale = NO_VIEWPORT_META.pageScaleFactor
    // Where the button's centre is painted in the frame, which is where the finger goes.
    const paintedX = ((BUTTON.left + BUTTON.right) / 2) * scale
    const paintedY = ((BUTTON.top + BUTTON.bottom) / 2) * scale

    const point = mapScreenToBrowserPoint(paintedX, paintedY, layout, NO_VIEWPORT_META, NO_ZOOM)!

    expect(point.x).toBeGreaterThanOrEqual(BUTTON.left)
    expect(point.x).toBeLessThanOrEqual(BUTTON.right)
    expect(point.y).toBeGreaterThanOrEqual(BUTTON.top)
    expect(point.y).toBeLessThanOrEqual(BUTTON.bottom)
    // What the device proof recorded instead: the frame's own device space, 41% of the aim, on BODY.
    expect(point).not.toEqual({ x: 30, y: 56 })
  })

  it('divides the frame device space by the page scale and adds no scroll offset', () => {
    const layout = { width: 400, height: 600 }
    const metadata = {
      deviceWidth: 400,
      deviceHeight: 600,
      pageScaleFactor: 0.5,
      scrollOffsetX: 70,
      scrollOffsetY: 300
    }

    expect(mapScreenToBrowserPoint(100, 200, layout, metadata, NO_ZOOM)).toEqual({ x: 200, y: 400 })
  })

  it('leaves web view mode where it was, at a page scale of one', () => {
    const layout = { width: 402, height: 593 }
    const metadata = { deviceWidth: 402, deviceHeight: 593, pageScaleFactor: 1 }

    expect(mapScreenToBrowserPoint(120, 240, layout, metadata, NO_ZOOM)).toEqual({ x: 120, y: 240 })
  })

  it('reads a missing or unusable page scale as one rather than dividing by it', () => {
    const layout = { width: 402, height: 593 }
    for (const pageScaleFactor of [undefined, 0, -1, Number.NaN]) {
      expect(
        mapScreenToBrowserPoint(
          120,
          240,
          layout,
          { deviceWidth: 402, deviceHeight: 593, pageScaleFactor },
          NO_ZOOM
        )
      ).toEqual({ x: 120, y: 240 })
    }
  })

  it('grows the touch radius by the page scale, because a CSS pixel is smaller', () => {
    const layout = { width: 400, height: 600 }
    const metadata = { deviceWidth: 400, deviceHeight: 600, pageScaleFactor: 0.5 }

    expect(computeBrowserTouchClickRadiusCss(layout, metadata, NO_ZOOM, 14)).toBe(28)
    expect(
      computeBrowserTouchClickRadiusCss(layout, { ...metadata, pageScaleFactor: 1 }, NO_ZOOM, 14)
    ).toBe(14)
  })

  it('scrolls the page by the page scale, not by the frame fit alone', () => {
    const layout = { width: 402, height: 593 }
    const geometry = computeBrowserFrameGeometry(layout, NO_VIEWPORT_META)

    // 100-screen-point flick spans 100/0.41 CSS pixels on default 980px page; frame fits pane 1:1.
    const delta = browserWheelDeltaFromScreen(0, 100, geometry, 1)

    expect(delta.dy).toBe(-244)
    expect(delta.dx).toBe(0)
    // What it sent before: the screen delta itself, 41% of the scroll asked for.
    expect(delta.dy).not.toBe(-100)
  })

  it('leaves a web view scroll and a pinched one where they were', () => {
    const layout = { width: 402, height: 593 }
    const unscaled = computeBrowserFrameGeometry(layout, {
      deviceWidth: 402,
      deviceHeight: 593,
      pageScaleFactor: 1
    })

    expect(browserWheelDeltaFromScreen(0, 100, unscaled, 1)).toEqual({ dx: 0, dy: -100 })
    // A pinch to 2x halves what a screen point is worth, on top of whatever the page scale is.
    expect(browserWheelDeltaFromScreen(0, 100, unscaled, 2)).toEqual({ dx: 0, dy: -50 })
    expect(browserWheelDeltaFromScreen(-40, 0, null, 1)).toEqual({ dx: 40, dy: 0 })
  })

  it('rejects page-level touch coordinates instead of mixing coordinate spaces', () => {
    expect(readLocalTouchPoint({ pageX: 120, pageY: 240 })).toBeNull()
  })

  it('clamps zoom offsets after the viewport geometry changes', () => {
    const nextGeometry = computeBrowserFrameGeometry(
      { width: 390, height: 700 },
      { deviceWidth: 1280, deviceHeight: 720 }
    )!

    const clamped = clampBrowserZoomState(
      { scale: 3.5, offsetX: 300, offsetY: 500 },
      nextGeometry,
      1,
      3.5
    )

    expect(clamped.scale).toBe(3.5)
    expect(clamped.offsetX).toBe(300)
    expect(clamped.offsetY).toBeCloseTo(33.90625)
  })
})