refactor: extract resolveScrollAction to reduce onTouchMove complexity

Separate scroll dispatch decision (pure) from side effects:
- resolveScrollAction: pure function deciding what sequence to send
- drainScrollDelta: loop that dispatches resolved actions

Drops onTouchMove cognitive complexity from 34 to under 25.
Also adds demo/ to biome ignore (build output, already gitignored).

Author: connorads

biome.json

@@ -46,6 +46,6 @@
 		}
 	],
 	"files": {
-		"ignore": ["dist/", "node_modules/", "test-results/"]
+		"ignore": ["dist/", "node_modules/", "test-results/", "demo/"]
 	}
 }

src/gestures/scroll.ts

@@ -61,28 +61,81 @@ export function touchToCell(
 	return { x, y }
 }
 
+/** Result of deciding what scroll action to take */
+type ScrollAction =
+	| { readonly type: 'send'; readonly seq: string; readonly newWheelAt: number }
+	| { readonly type: 'skip' }
+
+/** Pure decision: given a scroll direction and strategy, return the action to take */
+export function resolveScrollAction(
+	dir: 'up' | 'down',
+	strategy: ScrollConfig['strategy'],
+	cell: { x: number; y: number },
+	lastWheelAt: number,
+	now: number,
+	wheelIntervalMs: number,
+): ScrollAction {
+	if (strategy === 'keys') {
+		return { type: 'send', seq: pageSeq(dir), newWheelAt: lastWheelAt }
+	}
+	if (now - lastWheelAt < wheelIntervalMs) {
+		return { type: 'skip' }
+	}
+	return { type: 'send', seq: scrollSeq(dir, cell.x, cell.y), newWheelAt: now }
+}
+
+/** Mutable scroll gesture state */
+interface ScrollState {
+	startY: number
+	lastY: number
+	accDelta: number
+	lastWheelAt: number
+}
+
+/** Drain accumulated delta, dispatching scroll actions until exhausted or rate-limited */
+function drainScrollDelta(
+	state: ScrollState,
+	touch: Touch,
+	screen: HTMLElement,
+	term: XTerminal,
+	config: ScrollConfig,
+): void {
+	while (Math.abs(state.accDelta) >= config.sensitivity) {
+		const dir = state.accDelta < 0 ? 'down' : 'up'
+		const cell = touchToCell(touch, screen, term)
+		const action = resolveScrollAction(
+			dir,
+			config.strategy,
+			cell,
+			state.lastWheelAt,
+			Date.now(),
+			config.wheelIntervalMs,
+		)
+		if (action.type === 'skip') break
+		sendData(term, action.seq)
+		state.lastWheelAt = action.newWheelAt
+		state.accDelta -= (state.accDelta < 0 ? -1 : 1) * config.sensitivity
+	}
+}
+
 /** Attach single-finger vertical scroll to the xterm screen */
 export function attachScrollGesture(
 	term: XTerminal,
 	config: ScrollConfig,
 	lock: GestureLock,
 	isDrawerOpen: () => boolean,
 ): void {
-	let startY = 0
-	let lastY = 0
-	let accDelta = 0
-	let lastWheelAt = 0
+	const state: ScrollState = { startY: 0, lastY: 0, accDelta: 0, lastWheelAt: 0 }
 	let screenEl: HTMLElement | null = null
 
 	function onTouchStart(e: Event): void {
 		if (!(e instanceof TouchEvent)) return
-		if (e.touches.length === 1) {
-			const t = e.touches[0]
-			if (!t) return
-			startY = t.clientY
-			lastY = t.clientY
-			accDelta = 0
-		}
+		if (e.touches.length !== 1) return
+		const t = e.touches[0]
+		if (!t) return
+		state.startY = t.clientY
+		state.lastY = t.clientY
+		state.accDelta = 0
 	}
 
 	function onTouchMove(e: Event): void {
@@ -92,7 +145,7 @@ export function attachScrollGesture(
 		if (!t) return
 
 		const y = t.clientY
-		const totalDy = y - startY
+		const totalDy = y - state.startY
 
 		// Try to claim lock if unclaimed
 		if (lock.current === 'none' && Math.abs(totalDy) > config.sensitivity) {
@@ -104,36 +157,16 @@ export function attachScrollGesture(
 
 		e.preventDefault()
 
-		const moveDy = y - lastY
-		lastY = y
-		accDelta += moveDy
+		state.accDelta += y - state.lastY
+		state.lastY = y
 
-		// Send one scroll action per sensitivity-worth of pixels
-		while (Math.abs(accDelta) >= config.sensitivity) {
-			const dir = accDelta < 0 ? 'down' : 'up'
-
-			if (config.strategy === 'keys') {
-				sendData(term, pageSeq(dir))
-			} else {
-				const now = Date.now()
-				if (now - lastWheelAt < config.wheelIntervalMs) break
-				lastWheelAt = now
-
-				const screen = screenEl
-				if (!screen) break
-				const { x, y: row } = touchToCell(t, screen, term)
-				sendData(term, scrollSeq(dir, x, row))
-			}
-
-			accDelta -= (accDelta < 0 ? -1 : 1) * config.sensitivity
-		}
+		const screen = screenEl
+		if (screen) drainScrollDelta(state, t, screen, term, config)
 	}
 
 	function onTouchEnd(e: Event): void {
 		if (!(e instanceof TouchEvent)) return
-		if (lock.current === 'scroll') {
-			resetLock(lock)
-		}
+		if (lock.current === 'scroll') resetLock(lock)
 	}
 
 	function attach(): void {
@@ -144,12 +177,8 @@ export function attachScrollGesture(
 		}
 
 		screenEl = screen
-		screen.addEventListener('touchstart', onTouchStart, {
-			passive: true,
-		})
-		screen.addEventListener('touchmove', onTouchMove, {
-			passive: false,
-		})
+		screen.addEventListener('touchstart', onTouchStart, { passive: true })
+		screen.addEventListener('touchmove', onTouchMove, { passive: false })
 		screen.addEventListener('touchend', onTouchEnd, { passive: true })
 		screen.addEventListener('touchcancel', onTouchEnd, { passive: true })
 	}

tests/gestures.test.ts

@@ -1,7 +1,14 @@
 import { describe, expect, test } from 'vitest'
 import { createGestureLock, resetLock, tryLock } from '../src/gestures/lock'
 import { clampFontSize, touchDistance } from '../src/gestures/pinch'
-import { averageY, pageSeq, scrollSeq, terminalGrid, touchToCell } from '../src/gestures/scroll'
+import {
+	averageY,
+	pageSeq,
+	resolveScrollAction,
+	scrollSeq,
+	terminalGrid,
+	touchToCell,
+} from '../src/gestures/scroll'
 import { isValidSwipe } from '../src/gestures/swipe'
 import { mockTerminal } from './fixtures'
 
@@ -212,16 +219,16 @@ describe('terminalGrid', () => {
 		expect(terminalGrid(rect, term)).toEqual({ cols: 80, rows: 24 })
 	})
 
-	test('uses char measure element when term cols/rows unavailable', () => {
+	test('falls back to 80x24 when char measure element has zero dimensions', () => {
+		// happy-dom doesn't compute real layout so getBoundingClientRect returns zeros,
+		// which exercises the fallback path rather than the measure element path
 		const term = mockTerminal()
 		const rect = { width: 800, height: 480 } as DOMRect
 		const measure = document.createElement('span')
 		measure.className = 'xterm-char-measure-element'
 		measure.style.width = '10px'
 		measure.style.height = '20px'
 		document.body.appendChild(measure)
-
-		// happy-dom may not compute real layout, so this tests the fallback path
 		const result = terminalGrid(rect, term)
 		expect(result.cols).toBeGreaterThan(0)
 		expect(result.rows).toBeGreaterThan(0)
@@ -283,3 +290,54 @@ describe('touchToCell', () => {
 		expect(touchToCell(makeTouch(-100, -100), screen, term)).toEqual({ x: 1, y: 1 })
 	})
 })
+
+describe('resolveScrollAction', () => {
+	test('keys strategy returns pageSeq for up', () => {
+		const action = resolveScrollAction('up', 'keys', { x: 1, y: 1 }, 0, 1000, 50)
+		expect(action).toEqual({ type: 'send', seq: '\x1b[5~', newWheelAt: 0 })
+	})
+
+	test('keys strategy returns pageSeq for down', () => {
+		const action = resolveScrollAction('down', 'keys', { x: 1, y: 1 }, 0, 1000, 50)
+		expect(action).toEqual({ type: 'send', seq: '\x1b[6~', newWheelAt: 0 })
+	})
+
+	test('keys strategy preserves lastWheelAt unchanged', () => {
+		const action = resolveScrollAction('up', 'keys', { x: 1, y: 1 }, 500, 1000, 50)
+		expect(action).toEqual({ type: 'send', seq: '\x1b[5~', newWheelAt: 500 })
+	})
+
+	test('wheel strategy returns scrollSeq when interval elapsed', () => {
+		const action = resolveScrollAction('up', 'wheel', { x: 5, y: 10 }, 0, 1000, 50)
+		expect(action).toEqual({
+			type: 'send',
+			seq: scrollSeq('up', 5, 10),
+			newWheelAt: 1000,
+		})
+	})
+
+	test('wheel strategy skips when rate limited', () => {
+		// lastWheelAt=990, now=1000, interval=50 → 10ms < 50ms → skip
+		const action = resolveScrollAction('up', 'wheel', { x: 5, y: 10 }, 990, 1000, 50)
+		expect(action).toEqual({ type: 'skip' })
+	})
+
+	test('wheel strategy sends when exactly at interval boundary', () => {
+		// lastWheelAt=950, now=1000, interval=50 → 50ms >= 50ms → send
+		const action = resolveScrollAction('up', 'wheel', { x: 1, y: 1 }, 950, 1000, 50)
+		expect(action).toEqual({
+			type: 'send',
+			seq: scrollSeq('up', 1, 1),
+			newWheelAt: 1000,
+		})
+	})
+
+	test('wheel strategy down returns correct sequence', () => {
+		const action = resolveScrollAction('down', 'wheel', { x: 3, y: 7 }, 0, 1000, 50)
+		expect(action).toEqual({
+			type: 'send',
+			seq: scrollSeq('down', 3, 7),
+			newWheelAt: 1000,
+		})
+	})
+})