diff --git a/apps/web/src/components/RightPanelTabs.tsx b/apps/web/src/components/RightPanelTabs.tsx index 5ff3bd9591b4f..5fe6a1cafb989 100644 --- a/apps/web/src/components/RightPanelTabs.tsx +++ b/apps/web/src/components/RightPanelTabs.tsx @@ -63,7 +63,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"; @@ -1009,9 +1009,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 bb3d5880fe957..6a497fae3e7cf 100644 --- a/apps/web/src/layout/PaneTabs.tsx +++ b/apps/web/src/layout/PaneTabs.tsx @@ -99,7 +99,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"; @@ -236,7 +241,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 }, ); @@ -671,6 +676,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): number | null { const tab = findStripTab(strip, tabId); @@ -763,7 +780,10 @@ export function LayoutPaneTabStrip({ holdPaneStrip(entry, place, motionMs); const row = strip.closest("[data-pane-header]"); const pane = row?.closest("[data-layout-tab-id]") ?? null; - 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 68686eb4710fe..fafaad9437d66 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; diff --git a/apps/web/src/layout/SurfaceHost.tsx b/apps/web/src/layout/SurfaceHost.tsx index 502594f41fcb1..90a115074bfd7 100644 --- a/apps/web/src/layout/SurfaceHost.tsx +++ b/apps/web/src/layout/SurfaceHost.tsx @@ -24,6 +24,7 @@ import { cn } from "../lib/utils"; import { layoutChordHeld, listenLayoutWheel, + scrollLeftByWheel, scrollTabStripFromRow, sidewaysWheelStripScroll, WHEEL_STREAM_IDLE_MS, @@ -1080,7 +1081,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); @@ -1113,7 +1114,7 @@ export function LayoutSurfaceHost({ event.preventDefault(); settleStripCamera(); noteUserStripScroll(); - scroller.scrollLeft += wheelDeltaPx(event.deltaX, event); + scrollLeftByWheel(scroller, event, wheelDeltaPx(event.deltaX, event)); }; // Decided once per wheel stream, as the browser latches a scroll to one target. let stream: { at: number; scroll: "native" | "script" | null } | null = null; @@ -1140,7 +1141,7 @@ export function LayoutSurfaceHost({ // Past a code block that ends the browser's scroll chain, script moves the strip. settleStripCamera(); noteUserStripScroll(); - scroller.scrollLeft += wheelDeltaPx(delta, event); + scrollLeftByWheel(scroller, event, wheelDeltaPx(delta, event)); }; // The strip itself moved right after a sideways wheel: the user's scroll. const onScroll = () => { diff --git a/apps/web/src/motion/gesture.browser.test.ts b/apps/web/src/motion/gesture.browser.test.ts index 20e80deabda91..7b2d2068cd900 100644 --- a/apps/web/src/motion/gesture.browser.test.ts +++ b/apps/web/src/motion/gesture.browser.test.ts @@ -1,6 +1,12 @@ -import { describe, expect, it } from "vite-plus/test"; +import { describe, expect, it, vi } from "vite-plus/test"; -import { listenLayoutWheel, sidewaysWheelStripScroll } from "./gesture"; +import { + listenLayoutWheel, + scrollLeftByWheel, + sidewaysWheelStripScroll, + wheelChaseStep, + wheelScrollTarget, +} from "./gesture"; function mountStrip(stripOverflow: string) { const strip = document.createElement("div"); @@ -112,3 +118,123 @@ describe("listenLayoutWheel", () => { expect(wheel.cancelled({ deltaY: 40 })).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); + }); +}); + +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 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); + 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("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, [ + [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 a29be40691915..c13247cf79f27 100644 --- a/apps/web/src/motion/gesture.ts +++ b/apps/web/src/motion/gesture.ts @@ -88,6 +88,97 @@ export function wheelDeltaPx(delta: number, event: WheelEvent): number { return delta; } +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, + 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)"); + 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 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 || Math.abs(element.scrollLeft - state.position) > 1) { + wheelChases.delete(element); + return; + } + state.target = Math.min(state.target, element.scrollWidth - element.clientWidth); + 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 sidewaysScroller(element: Element): { scrolls: boolean; stopsChain: boolean } { const style = getComputedStyle(element); const scroller = style.overflowX === "auto" || style.overflowX === "scroll"; @@ -135,7 +226,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)); } /**