From 8c6a50369fec730a643dbcca58a35f241c2351cd Mon Sep 17 00:00:00 2001 From: flamboh Date: Wed, 18 Nov 2026 07:23:37 +0000 Subject: [PATCH 1/6] fix(web): a notched mouse wheel eases the pane strip sideways Each notch of a mouse wheel moved the pane strip 85 to 200px in one frame. A notch now eases the strip toward a target that quick notches add to, as page scrolling does. Trackpad deltas still move it at once, and reduced motion keeps it instant. A sideways notch is told from a trackpad by the legacy wheel delta of its own axis. Made with Claude Opus 5.5 in Claude Code (T3 Code). --- apps/web/src/layout/SurfaceHost.tsx | 11 +++- apps/web/src/motion/gesture.browser.test.ts | 64 ++++++++++++++++++- apps/web/src/motion/gesture.ts | 71 ++++++++++++++++++++- 3 files changed, 139 insertions(+), 7 deletions(-) diff --git a/apps/web/src/layout/SurfaceHost.tsx b/apps/web/src/layout/SurfaceHost.tsx index 9c0a40f77a9d6..a31323c38656e 100644 --- a/apps/web/src/layout/SurfaceHost.tsx +++ b/apps/web/src/layout/SurfaceHost.tsx @@ -12,7 +12,12 @@ import { StatusDot } from "../components/ui/status-dot"; import { useMediaQuery } from "../hooks/useMediaQuery"; import { useScrollingWorkspacesEnabled } from "../hooks/useSettings"; import { cn, isMacPlatform } from "../lib/utils"; -import { scrollTabStripFromRow, sidewaysWheelScrollsStrip, wheelDeltaPx } from "../motion/gesture"; +import { + scrollLeftByWheel, + scrollTabStripFromRow, + sidewaysWheelScrollsStrip, + wheelDeltaPx, +} from "../motion/gesture"; import { noteStripScroll, PaneMotionSnapshot, usePaneMotion } from "../motion/paneMotion"; import { ChatPanelAnimationSuppressionProvider, @@ -974,7 +979,7 @@ export function LayoutSurfaceHost({ event.preventDefault(); settleStripCamera(); noteUserStripScroll(); - scroller.scrollLeft += wheelDeltaPx(delta, event); + scrollLeftByWheel(scroller, event, wheelDeltaPx(delta, event)); }; root.parentElement?.append(chrome); const stop = observeResize([root, scroller, stage], update); @@ -1008,7 +1013,7 @@ export function LayoutSurfaceHost({ event.preventDefault(); settleStripCamera(); noteUserStripScroll(); - scroller.scrollLeft += wheelDeltaPx(delta, event); + scrollLeftByWheel(scroller, event, wheelDeltaPx(delta, event)); }; const onWheel = (event: WheelEvent) => { if (held(event) && Math.abs(event.deltaX) > Math.abs(event.deltaY)) diff --git a/apps/web/src/motion/gesture.browser.test.ts b/apps/web/src/motion/gesture.browser.test.ts index bd413165754f9..b2e149c9a5b9e 100644 --- a/apps/web/src/motion/gesture.browser.test.ts +++ b/apps/web/src/motion/gesture.browser.test.ts @@ -1,6 +1,11 @@ import { describe, expect, it } from "vite-plus/test"; -import { sidewaysWheelScrollsStrip } from "./gesture"; +import { + isDiscreteWheel, + sidewaysWheelScrollsStrip, + wheelChaseStep, + wheelScrollTarget, +} from "./gesture"; function mountStrip(stripOverflow: string) { const strip = document.createElement("div"); @@ -42,3 +47,60 @@ describe("sidewaysWheelScrollsStrip", () => { expect(sidewaysWheelScrollsStrip(strip.pathFrom("[data-row]"), strip, 40, 3)).toBe(false); }); }); + +describe("isDiscreteWheel", () => { + const wheel = (init: { + deltaX?: number; + deltaY?: number; + wheelDeltaX?: number; + wheelDeltaY?: number; + deltaMode?: number; + }) => + ({ + deltaX: 0, + deltaY: 0, + wheelDeltaX: 0, + wheelDeltaY: 0, + deltaMode: 0, + ...init, + }) as unknown as WheelEvent; + + it("tells a notched wheel from a trackpad on either axis", () => { + expect(isDiscreteWheel(wheel({ deltaY: 100, wheelDeltaY: -120 }))).toBe(true); + expect(isDiscreteWheel(wheel({ deltaY: 53, wheelDeltaY: -120 }))).toBe(true); + expect(isDiscreteWheel(wheel({ deltaX: 85, wheelDeltaX: -120 }))).toBe(true); + expect(isDiscreteWheel(wheel({ deltaX: -200, wheelDeltaX: 240 }))).toBe(true); + expect(isDiscreteWheel(wheel({ deltaX: 3, deltaMode: 1 }))).toBe(true); + expect(isDiscreteWheel(wheel({ deltaX: 4, wheelDeltaX: -12 }))).toBe(false); + expect(isDiscreteWheel(wheel({ deltaX: 40, wheelDeltaX: -120 }))).toBe(false); + expect(isDiscreteWheel(wheel({ deltaY: 2.5, wheelDeltaY: -7 }))).toBe(false); + expect( + isDiscreteWheel(wheel({ deltaX: 120, deltaY: 1, wheelDeltaX: -360, wheelDeltaY: -3 })), + ).toBe(false); + }); +}); + +describe("wheelScrollTarget", () => { + it("adds quick notches onto the target still being reached", () => { + expect(wheelScrollTarget(100, undefined, 85, 1000)).toBe(185); + expect(wheelScrollTarget(130, 185, 85, 1000)).toBe(270); + expect(wheelScrollTarget(130, 185, -85, 1000)).toBe(45); + }); + + it("keeps the target inside the scroll range", () => { + expect(wheelScrollTarget(950, undefined, 120, 1000)).toBe(1000); + expect(wheelScrollTarget(20, undefined, -120, 1000)).toBe(0); + expect(wheelScrollTarget(0, undefined, 120, -5)).toBe(0); + }); +}); + +describe("wheelChaseStep", () => { + it("eases toward the target and lands on it", () => { + const first = wheelChaseStep(0, 100, 16); + expect(first).toBeGreaterThan(0); + expect(first).toBeLessThan(100); + expect(wheelChaseStep(first, 100, 16)).toBeGreaterThan(first); + expect(wheelChaseStep(99.8, 100, 16)).toBe(100); + expect(wheelChaseStep(100, 0, 1000)).toBe(0); + }); +}); diff --git a/apps/web/src/motion/gesture.ts b/apps/web/src/motion/gesture.ts index f962ea8cc1bae..7c72efe8873df 100644 --- a/apps/web/src/motion/gesture.ts +++ b/apps/web/src/motion/gesture.ts @@ -71,13 +71,19 @@ export function rubberBandClampDerivative( return (c * d * d) / (c * diff + d) ** 2; } -/** Legacy wheelDeltaY distinguishes discrete 120-unit notches from precise trackpad deltas; +/** Legacy wheelDelta distinguishes discrete 120-unit notches from precise trackpad deltas; * ambiguous pixel events remain swipe gestures. */ export function isDiscreteWheel(event: WheelEvent): boolean { if (event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL) return true; - const legacy = (event as WheelEvent & { wheelDeltaY?: number }).wheelDeltaY; + const sideways = Math.abs(event.deltaX) > Math.abs(event.deltaY); + const { wheelDeltaX, wheelDeltaY } = event as WheelEvent & { + wheelDeltaX?: number; + wheelDeltaY?: number; + }; + const legacy = sideways ? wheelDeltaX : wheelDeltaY; + const delta = sideways ? event.deltaX : event.deltaY; if (typeof legacy !== "number" || legacy === 0 || legacy % 120 !== 0) return false; - return legacy !== -3 * event.deltaY && legacy !== -event.deltaY; + return legacy !== -3 * delta && legacy !== -delta; } /** Wheel deltas in px; a notch in lines or pages counts as one screenful step anyway. */ @@ -87,6 +93,65 @@ export function wheelDeltaPx(delta: number, event: WheelEvent): number { return delta; } +const WHEEL_EASE_MS = 40; +const wheelChases = new WeakMap(); +let reducedMotion: MediaQueryList | null = null; + +export function wheelScrollTarget( + position: number, + pending: number | undefined, + delta: number, + max: number, +): number { + const base = + pending !== undefined && Math.sign(pending - position) === Math.sign(delta) + ? pending + : position; + return Math.min(Math.max(base + delta, 0), Math.max(0, max)); +} + +export function wheelChaseStep(position: number, target: number, elapsedMs: number): number { + const next = target + (position - target) * Math.exp(-elapsedMs / WHEEL_EASE_MS); + return Math.abs(target - next) < 0.5 ? target : next; +} + +export function scrollLeftByWheel(element: HTMLElement, event: WheelEvent, delta: number): boolean { + const position = element.scrollLeft; + const max = element.scrollWidth - element.clientWidth; + reducedMotion ??= window.matchMedia("(prefers-reduced-motion: reduce)"); + if (!isDiscreteWheel(event) || reducedMotion.matches) { + wheelChases.delete(element); + element.scrollLeft = position + delta; + return Math.min(Math.max(position + delta, 0), max) !== position; + } + const chase = wheelChases.get(element); + const target = wheelScrollTarget(position, chase?.target, delta, max); + if (chase) { + chase.target = target; + return true; + } + if (target === position) return false; + const state = { target, time: performance.now(), position }; + wheelChases.set(element, state); + const step = (time: number) => { + if (wheelChases.get(element) !== state) return; + if (!element.isConnected) { + wheelChases.delete(element); + return; + } + state.target = Math.min(state.target, element.scrollWidth - element.clientWidth); + if (Math.abs(element.scrollLeft - state.position) > 1) state.position = element.scrollLeft; + const next = wheelChaseStep(state.position, state.target, Math.max(0, time - state.time)); + state.time = Math.max(time, state.time); + state.position = next; + element.scrollLeft = next; + if (next === state.target) wheelChases.delete(element); + else requestAnimationFrame(step); + }; + requestAnimationFrame(step); + return true; +} + function scrollsSideways(element: Element): boolean { if (element.scrollWidth <= element.clientWidth) return false; const { overflowX } = getComputedStyle(element); From d3ab57a8afab495863e0ced2bd8e3588e8e18c35 Mon Sep 17 00:00:00 2001 From: flamboh Date: Wed, 18 Nov 2026 07:28:07 +0000 Subject: [PATCH 2/6] fix(web): a notched mouse wheel eases overflowing tab rows A vertical mouse wheel over a pane's tab row, or a sideways wheel over the row's controls, moved the row a whole notch in one frame, as did a vertical wheel over a side panel's tab row. They now ease like the pane strip; trackpads still move them at once. Made with Claude Opus 5.5 in Claude Code (T3 Code). --- apps/web/src/components/RightPanelTabs.tsx | 6 ++---- apps/web/src/layout/PaneTabs.tsx | 9 +++++++-- apps/web/src/motion/gesture.ts | 2 +- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/apps/web/src/components/RightPanelTabs.tsx b/apps/web/src/components/RightPanelTabs.tsx index c326df25be92b..84cbd4853f30e 100644 --- a/apps/web/src/components/RightPanelTabs.tsx +++ b/apps/web/src/components/RightPanelTabs.tsx @@ -61,7 +61,7 @@ import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip"; import { Menu, MenuPopup, MenuTrigger } from "~/components/ui/menu"; import { useBrowserDefaults } from "~/browser/browserDefaults"; import { ScrollArea } from "~/components/ui/scroll-area"; -import { scrollTabStripFromRow } from "../motion/gesture"; +import { scrollLeftByWheel, scrollTabStripFromRow } from "../motion/gesture"; import { PanelTabCloseButton } from "~/components/ui/panel-tab-close-button"; import { useTheme } from "~/hooks/useTheme"; import { useMediaQuery } from "~/hooks/useMediaQuery"; @@ -956,9 +956,7 @@ export function RightPanelTabs(props: RightPanelTabsProps) { if (event.deltaMode === WheelEvent.DOM_DELTA_LINE) delta *= 16; if (event.deltaMode === WheelEvent.DOM_DELTA_PAGE) delta *= viewport.clientWidth; - const previousScrollLeft = viewport.scrollLeft; - viewport.scrollLeft += delta; - if (viewport.scrollLeft === previousScrollLeft) return; + if (!scrollLeftByWheel(viewport, event, delta)) return; event.preventDefault(); update(); }; diff --git a/apps/web/src/layout/PaneTabs.tsx b/apps/web/src/layout/PaneTabs.tsx index 81b2daf7b6c9c..1d460208e45e7 100644 --- a/apps/web/src/layout/PaneTabs.tsx +++ b/apps/web/src/layout/PaneTabs.tsx @@ -93,7 +93,12 @@ import { beginLayoutContentDrag, beginLayoutTabDrag } from "./layoutDrag"; import { useLayoutPane } from "./layoutPaneContext"; import { isScrollingWorkspacesEnabled } from "./layoutBehavior"; import { useLayoutStore } from "./layoutStore"; -import { scrollTabStripFromRow, setWheelScroller, wheelDeltaPx } from "../motion/gesture"; +import { + scrollLeftByWheel, + scrollTabStripFromRow, + setWheelScroller, + wheelDeltaPx, +} from "../motion/gesture"; import { useClientSettings } from "../hooks/useSettings"; import { useMediaQuery } from "../hooks/useMediaQuery"; import { surfaceTabTitle, terminalTabTitle } from "./surfaceTabLabels"; @@ -209,7 +214,7 @@ function createPaneStrip(role?: "panel"): PaneStrip { return; event.preventDefault(); event.stopPropagation(); - strip.scrollLeft += wheelDeltaPx(event.deltaY, event); + scrollLeftByWheel(strip, event, wheelDeltaPx(event.deltaY, event)); }, { passive: false }, ); diff --git a/apps/web/src/motion/gesture.ts b/apps/web/src/motion/gesture.ts index 7c72efe8873df..c2392951bc43d 100644 --- a/apps/web/src/motion/gesture.ts +++ b/apps/web/src/motion/gesture.ts @@ -168,7 +168,7 @@ export function scrollTabStripFromRow(event: WheelEvent, strip: HTMLElement): vo if (event.composedPath().includes(strip) && event.deltaX !== 0) return; event.preventDefault(); event.stopPropagation(); - strip.scrollLeft += wheelDeltaPx(delta, event); + scrollLeftByWheel(strip, event, wheelDeltaPx(delta, event)); } export function sidewaysWheelScrollsStrip( From 6359e57d174457a1bf1261463905b7847087a47a Mon Sep 17 00:00:00 2001 From: flamboh Date: Wed, 18 Nov 2026 07:30:58 +0000 Subject: [PATCH 3/6] fix(web): a vertical mouse wheel over the gaps of a tab row scrolls its tabs A vertical wheel scrolled an overflowing tab row only over a tab. Over the gaps between tabs the row passes presses through, so the wheel did nothing there. The row now scrolls its tabs from anywhere over them. Made with Claude Opus 5.5 in Claude Code (T3 Code). --- apps/web/src/layout/PaneTabs.tsx | 17 ++++++++++++++++- .../web/src/layout/SurfaceHost.browser.test.tsx | 12 ++++++++++++ 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/apps/web/src/layout/PaneTabs.tsx b/apps/web/src/layout/PaneTabs.tsx index 1d460208e45e7..9fdcba0c4d8a8 100644 --- a/apps/web/src/layout/PaneTabs.tsx +++ b/apps/web/src/layout/PaneTabs.tsx @@ -529,6 +529,18 @@ function slideOnPress(entry: PaneStrip, event: PointerEvent): void { window.addEventListener("pointercancel", settle, true); } +function scrollStripFromGap(event: WheelEvent, strip: HTMLElement): void { + if (event.defaultPrevented || event.ctrlKey || event.metaKey || event.altKey) return; + if (Math.abs(event.deltaX) >= Math.abs(event.deltaY)) return; + if (strip.scrollWidth <= strip.clientWidth) return; + const box = strip.getBoundingClientRect(); + if (event.clientX < box.left || event.clientX >= box.right) return; + if (event.clientY < box.top || event.clientY >= box.bottom) return; + event.preventDefault(); + event.stopPropagation(); + scrollLeftByWheel(strip, event, wheelDeltaPx(event.deltaY, event)); +} + /** Reveal the active tab in a strip wider than its pane, keeping the joined tab's ears inside. */ function revealPaneTab(strip: HTMLElement, tabId: string | null): void { const tab = findStripTab(strip, tabId); @@ -595,7 +607,10 @@ export function LayoutPaneTabStrip({ }; holdPaneStrip(entry, place, motionMs); const row = strip.closest("[data-pane-header]"); - const wheel = (event: WheelEvent) => scrollTabStripFromRow(event, strip); + const wheel = (event: WheelEvent) => { + scrollStripFromGap(event, strip); + scrollTabStripFromRow(event, strip); + }; row?.addEventListener("wheel", wheel, { passive: false }); markStripOverflow(strip); // The collapsed sidebar's inset moves the strip off the pane's edge diff --git a/apps/web/src/layout/SurfaceHost.browser.test.tsx b/apps/web/src/layout/SurfaceHost.browser.test.tsx index a20999b8cbd94..b0b03889c8b75 100644 --- a/apps/web/src/layout/SurfaceHost.browser.test.tsx +++ b/apps/web/src/layout/SurfaceHost.browser.test.tsx @@ -296,6 +296,18 @@ it("scrolls overflowing pane tabs from the add button without moving the workspa const header = strip.closest("[data-pane-header]")!; const workspace = screen.container.querySelector("[data-layout-strip]")!; await vi.waitFor(() => expect(strip.scrollWidth).toBeGreaterThan(strip.clientWidth + 200)); + const stripBox = strip.getBoundingClientRect(); + const revealed = strip.scrollLeft; + header.dispatchEvent( + new WheelEvent("wheel", { + deltaY: -30, + clientX: stripBox.left + stripBox.width / 2, + clientY: stripBox.top + stripBox.height / 2, + bubbles: true, + cancelable: true, + }), + ); + expect(strip.scrollLeft).toBe(revealed - 30); strip.scrollLeft = 100; const before = workspace.scrollLeft; From 5598b2241fce8327461f04a51908352d3c875ae1 Mon Sep 17 00:00:00 2001 From: flamboh Date: Wed, 18 Nov 2026 07:41:12 +0000 Subject: [PATCH 4/6] fix(web): a wheel's ease lets go when something else scrolls the row An eased wheel scroll took any other scroll that happened meanwhile, such as the strip's camera or a tab reveal, as its new start and carried on to its own target. It now stops there. Made with Claude Opus 5.5 in Claude Code (T3 Code). --- apps/web/src/motion/gesture.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/apps/web/src/motion/gesture.ts b/apps/web/src/motion/gesture.ts index c2392951bc43d..9488ada6d4f98 100644 --- a/apps/web/src/motion/gesture.ts +++ b/apps/web/src/motion/gesture.ts @@ -135,12 +135,11 @@ export function scrollLeftByWheel(element: HTMLElement, event: WheelEvent, delta wheelChases.set(element, state); const step = (time: number) => { if (wheelChases.get(element) !== state) return; - if (!element.isConnected) { + if (!element.isConnected || Math.abs(element.scrollLeft - state.position) > 1) { wheelChases.delete(element); return; } state.target = Math.min(state.target, element.scrollWidth - element.clientWidth); - if (Math.abs(element.scrollLeft - state.position) > 1) state.position = element.scrollLeft; const next = wheelChaseStep(state.position, state.target, Math.max(0, time - state.time)); state.time = Math.max(time, state.time); state.position = next; From ab377a17873b451882d4cf2d5fcb65a5df90995c Mon Sep 17 00:00:00 2001 From: flamboh Date: Wed, 18 Nov 2026 09:17:10 +0000 Subject: [PATCH 5/6] fix(web): a notched mouse on macOS eases the strip and tab rows too Chromium on macOS gives a notched wheel's event the same legacy delta, three times its pixel delta, that a trackpad's event of that size has, so every notch read as a trackpad and moved at once. Each event now reads as notched, trackpad or either, and a wheel gesture moves directly from its first event that only a trackpad sends until it pauses. A trackpad delta while an ease runs moves at once and keeps the ease's remaining distance. Made with Claude Opus 5.5 in Claude Code (T3 Code). --- apps/web/src/motion/gesture.browser.test.ts | 72 ++++++++++++++++++++- apps/web/src/motion/gesture.ts | 39 ++++++++++- 2 files changed, 107 insertions(+), 4 deletions(-) diff --git a/apps/web/src/motion/gesture.browser.test.ts b/apps/web/src/motion/gesture.browser.test.ts index b2e149c9a5b9e..6638f53a86106 100644 --- a/apps/web/src/motion/gesture.browser.test.ts +++ b/apps/web/src/motion/gesture.browser.test.ts @@ -1,7 +1,8 @@ -import { describe, expect, it } from "vite-plus/test"; +import { describe, expect, it, vi } from "vite-plus/test"; import { isDiscreteWheel, + scrollLeftByWheel, sidewaysWheelScrollsStrip, wheelChaseStep, wheelScrollTarget, @@ -104,3 +105,72 @@ describe("wheelChaseStep", () => { expect(wheelChaseStep(100, 0, 1000)).toBe(0); }); }); + +describe("scrollLeftByWheel", () => { + function mountRow() { + const row = document.createElement("div"); + row.style.cssText = "width: 300px; height: 40px; overflow-x: auto"; + row.innerHTML = `
`; + document.body.append(row); + return Object.assign(row, { [Symbol.dispose]: () => row.remove() }); + } + const sideways = (timeStamp: number, deltaX: number, wheelDeltaX: number) => + ({ + deltaMode: 0, + deltaX, + deltaY: 0, + wheelDeltaX, + wheelDeltaY: 0, + timeStamp, + }) as unknown as WheelEvent; + const feed = (row: HTMLElement, events: readonly (readonly [number, number, number])[]) => + events.map(([time, delta, legacy]) => { + scrollLeftByWheel(row, sideways(time, delta, legacy), delta); + return row.scrollLeft; + }); + + it("eases a notched mouse on macOS whose ticks match its line deltas", async () => { + using row = mountRow(); + const positions = feed(row, [ + [10_000, 120, -360], + [10_030, 160, -480], + [10_050, 200, -600], + ]); + expect(positions).toEqual([0, 0, 0]); + await vi.waitFor(() => expect(row.scrollLeft).toBe(480)); + }); + + it("eases slow macOS notches with fractional deltas", async () => { + using row = mountRow(); + row.scrollLeft = 100; + const positions = feed(row, [ + [20_000, -4.0002, 120], + [20_040, -4.0002, 120], + [20_070, -8.0005, 120], + ]); + expect(positions).toEqual([100, 100, 100]); + await vi.waitFor(() => expect(row.scrollLeft).toBeCloseTo(84, 0)); + }); + + it("keeps a trackpad swipe direct when it passes whole ticks mid-swipe", () => { + using row = mountRow(); + const deltas = [3, 7, 18, 40, 33, 120, 61, 25, 9, 2]; + const positions = feed( + row, + deltas.map((delta, index) => [30_000 + index * 16, delta, -3 * delta] as const), + ); + let sum = 0; + expect(positions).toEqual(deltas.map((delta) => (sum += delta))); + }); + + it("finishes an eased first tick without losing it when the swipe turns out direct", async () => { + using row = mountRow(); + const positions = feed(row, [ + [40_000, 40, -120], + [40_016, 7, -21], + [40_032, 9, -27], + ]); + expect(positions).toEqual([0, 7, 16]); + await vi.waitFor(() => expect(row.scrollLeft).toBe(56)); + }); +}); diff --git a/apps/web/src/motion/gesture.ts b/apps/web/src/motion/gesture.ts index 9488ada6d4f98..30e78958538e7 100644 --- a/apps/web/src/motion/gesture.ts +++ b/apps/web/src/motion/gesture.ts @@ -96,6 +96,36 @@ export function wheelDeltaPx(delta: number, event: WheelEvent): number { const WHEEL_EASE_MS = 40; const wheelChases = new WeakMap(); let reducedMotion: MediaQueryList | null = null; +const wheelStream = { last: Number.NEGATIVE_INFINITY, direct: false }; + +function wholeTicks(ticks: number): boolean { + return Math.round(ticks) !== 0 && Math.abs(ticks - Math.round(ticks)) < 0.05; +} + +function wheelSource(event: WheelEvent): "notched" | "trackpad" | "either" { + if (event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL) return "notched"; + const sideways = Math.abs(event.deltaX) > Math.abs(event.deltaY); + const { wheelDeltaX = 0, wheelDeltaY = 0 } = event as WheelEvent & { + wheelDeltaX?: number; + wheelDeltaY?: number; + }; + const [delta, other, legacy, otherLegacy] = sideways + ? [event.deltaX, event.deltaY, wheelDeltaX, wheelDeltaY] + : [event.deltaY, event.deltaX, wheelDeltaY, wheelDeltaX]; + if (other !== 0 || otherLegacy !== 0) return "trackpad"; + const ratio = window.devicePixelRatio; + const zoomed = !Number.isInteger(ratio) && wholeTicks((legacy * ratio) / 120); + if (!wholeTicks(legacy / 120) && !zoomed) return "trackpad"; + if (Math.abs(legacy + delta) <= 1) return "trackpad"; + return Math.abs(legacy + 3 * delta) <= 1 ? "either" : "notched"; +} + +function easesWheel(event: WheelEvent): boolean { + if (event.timeStamp - wheelStream.last > WHEEL_STREAM_IDLE_MS) wheelStream.direct = false; + wheelStream.last = event.timeStamp; + if (wheelSource(event) === "trackpad") wheelStream.direct = true; + return !wheelStream.direct; +} export function wheelScrollTarget( position: number, @@ -119,12 +149,15 @@ export function scrollLeftByWheel(element: HTMLElement, event: WheelEvent, delta const position = element.scrollLeft; const max = element.scrollWidth - element.clientWidth; reducedMotion ??= window.matchMedia("(prefers-reduced-motion: reduce)"); - if (!isDiscreteWheel(event) || reducedMotion.matches) { - wheelChases.delete(element); + const chase = wheelChases.get(element); + if (!easesWheel(event) || reducedMotion.matches) { + if (chase) { + chase.position += delta; + chase.target = Math.min(Math.max(chase.target + delta, 0), Math.max(0, max)); + } element.scrollLeft = position + delta; return Math.min(Math.max(position + delta, 0), max) !== position; } - const chase = wheelChases.get(element); const target = wheelScrollTarget(position, chase?.target, delta, max); if (chase) { chase.target = target; From b4d70ed7667e09f00f83b1469164cc0a7035d726 Mon Sep 17 00:00:00 2001 From: flamboh Date: Sun, 22 Nov 2026 10:39:26 +0000 Subject: [PATCH 6/6] test(web): notches under browser zoom ease and zoomed trackpad deltas stay direct Uses the wheel event values Chromium gives at 110% and 150% browser zoom, where the legacy wheel delta is 120 divided by the zoom. Made with Claude Opus 5.5 in Claude Code (T3 Code). --- apps/web/src/motion/gesture.browser.test.ts | 26 +++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/apps/web/src/motion/gesture.browser.test.ts b/apps/web/src/motion/gesture.browser.test.ts index 13b03804d9372..7b2d2068cd900 100644 --- a/apps/web/src/motion/gesture.browser.test.ts +++ b/apps/web/src/motion/gesture.browser.test.ts @@ -161,6 +161,12 @@ describe("scrollLeftByWheel", () => { wheelDeltaY: 0, timeStamp, }) as unknown as WheelEvent; + const zoomTo = (ratio: number) => { + Object.defineProperty(window, "devicePixelRatio", { value: ratio, configurable: true }); + return { + [Symbol.dispose]: () => Reflect.deleteProperty(window, "devicePixelRatio"), + }; + }; const feed = (row: HTMLElement, events: readonly (readonly [number, number, number])[]) => events.map(([time, delta, legacy]) => { scrollLeftByWheel(row, sideways(time, delta, legacy), delta); @@ -201,6 +207,26 @@ describe("scrollLeftByWheel", () => { expect(positions).toEqual(deltas.map((delta) => (sum += delta))); }); + it("eases notches under browser zoom and keeps zoomed trackpad deltas direct", async () => { + using row = mountRow(); + using _zoom = zoomTo(1.100000023841858); + expect(feed(row, [[35_000, 99.99999783255842, -109]])).toEqual([0]); + await vi.waitFor(() => expect(row.scrollLeft).toBeCloseTo(100, 0)); + zoomTo(1.5); + expect(feed(row, [[36_000, 100, -80]])).toEqual([row.scrollLeft]); + await vi.waitFor(() => expect(row.scrollLeft).toBeCloseTo(200, 0)); + zoomTo(1.100000023841858); + const deltas = [11.818181, 6.363636, 20.909091]; + const positions = feed( + row, + deltas.map((delta, index) => [37_000 + index * 16, delta, -Math.trunc(3 * delta)] as const), + ); + let sum = row.scrollLeft - deltas.reduce((total, delta) => total + delta, 0); + expect(positions.map((value) => Math.round(value))).toEqual( + deltas.map((delta) => Math.round((sum += delta))), + ); + }); + it("finishes an eased first tick without losing it when the swipe turns out direct", async () => { using row = mountRow(); const positions = feed(row, [