fix(diffs): preserve the reading edge and wheel travel

This commit is contained in:
Brennan Benson
2026-11-11 03:15:26 -08:00
parent a806753bf7
commit b0ba18c5d5
5 changed files with 324 additions and 14 deletions
@@ -170,19 +170,23 @@ export class CombinedDiffViewportAnchor {
}
const previous = this.committed?.point
this.readingDirty = false
const edge = this.context.getDirection() === 'up' ? this.context.getHeight() : 0
const step = this.context.getDirection() === 'up' ? -1 : 1
const visible = this.context.getVisible()
for (
let index = step === 1 ? 0 : visible.length - 1;
index >= 0 && index < visible.length;
index += step
) {
const point = visible[index].binding?.capture(edge, previous)
if (point) {
this.preserve(point)
return
const up = this.context.getDirection() === 'up'
const edge = up ? this.context.getHeight() : 0
const offset = this.context.getTop() + edge
const extents = this.context.getIndex()
const item = this.context.getVisible().find((candidate) => {
const index = extents.position(candidate.key)
if (index === undefined || extents.heightAt(index) <= 0) {
return false
}
const start = extents.startAt(index)
const end = start + extents.heightAt(index)
return up ? start < offset && offset <= end : start <= offset && offset < end
})
const point = item?.binding?.capture(edge, previous)
if (point) {
this.preserve(point)
return
}
this.clearPoint()
}
@@ -0,0 +1,233 @@
// @vitest-environment happy-dom
import { expect, it, vi } from 'vitest'
import { installDiffEditorShiftWheelScroll } from '../../diff/monaco-view/diff-editor-shift-wheel-scroll'
import { CombinedDiffViewportOwner } from './combined-diff-viewport-owner'
function viewport(): { owner: CombinedDiffViewportOwner; host: HTMLDivElement; close(): void } {
const owner = new CombinedDiffViewportOwner()
const host = document.createElement('div')
Object.defineProperties(host, {
clientWidth: { value: 800 },
clientHeight: { value: 500 }
})
document.body.append(host)
const unmount = owner.mount(host)
return {
owner,
host,
close: () => {
unmount()
owner.dispose()
host.remove()
}
}
}
function row(key: string, index: number, height = 1000, generation = 'ready') {
return { key, index, height, generation, collapsed: false }
}
async function commit(): Promise<void> {
await Promise.resolve()
await Promise.resolve()
}
function bindPoint(owner: CombinedDiffViewportOwner, key: string, offset: number) {
const item = owner.getItem(key)!
const point = {
resolveScrollTop: (displacement: number) =>
owner.getItemLayout(key)!.start + offset - displacement,
project: () => owner.getItemLayout(key)!.start + offset - owner.getScrollTop(),
dispose: () => {}
}
owner.bind(item, {
apply: () => {},
readHeight: () => 1000,
capture: () => point,
hasFocus: () => false,
detach: () => {}
})
return point
}
function wheel(target: HTMLElement, deltaY: number, init: WheelEventInit = {}): WheelEvent {
const event = new WheelEvent('wheel', { bubbles: true, cancelable: true, deltaY, ...init })
target.dispatchEvent(event)
return event
}
it('keeps the beginning when a loading edge grows before the next native row', async () => {
const view = viewport()
const { owner } = view
try {
owner.setItems([row('first', 0, 88, 'loading'), row('next', 1)])
bindPoint(owner, 'next', 28)
await commit()
expect(owner.getScrollTop()).toBe(0)
owner.setItems([row('first', 0), row('next', 1)])
await commit()
expect(owner.getScrollTop()).toBe(0)
owner.measure(owner.getItem('first')!, 1200)
await commit()
expect(owner.getAnchor()).toEqual({ key: 'first', offset: 0 })
expect(owner.getScrollTop()).toBe(0)
} finally {
view.close()
}
})
it('keeps a non-native bottom edge at its exact boundary while scrolling upward', async () => {
const view = viewport()
const { owner } = view
try {
owner.setItems([row('first', 0), row('bottom', 1, 88, 'loading'), row('tail', 2)])
bindPoint(owner, 'first', 980)
await commit()
owner.input(900)
owner.input(-312)
expect(owner.getScrollTop()).toBe(588)
owner.setItems([row('first', 0), row('bottom', 1), row('tail', 2)])
await commit()
expect(owner.getScrollTop()).toBe(1500)
expect(owner.getItemLayout('bottom')!.start - owner.getScrollTop()).toBe(-500)
} finally {
view.close()
}
})
it('preserves an explicit note request across a non-native edge without repeating focus', async () => {
const view = viewport()
const { owner } = view
try {
owner.setItems([row('first', 0, 88, 'loading'), row('next', 1)])
const point = bindPoint(owner, 'next', 28)
const focus = vi.fn()
await commit()
owner.reveal(owner.getItem('next')!, () => point, focus)
await commit()
expect(focus).toHaveBeenCalledTimes(1)
expect(owner.getScrollTop()).toBe(0)
owner.setItems([row('first', 0), row('next', 1)])
await commit()
expect(owner.getScrollTop()).toBe(912)
expect(point.project()).toBe(116)
expect(focus).toHaveBeenCalledTimes(1)
} finally {
view.close()
}
})
it('routes browser wheel units through the owner without tick normalization or duplicate listeners', async () => {
const view = viewport()
const { owner } = view
try {
owner.setItems([row('first', 0, 10000)])
await commit()
expect(wheel(owner.scene, 120).defaultPrevented).toBe(true)
expect(owner.getScrollTop()).toBe(120)
wheel(owner.scene, 7.5)
expect(owner.getScrollTop()).toBe(127.5)
wheel(owner.scene, 2, { deltaMode: WheelEvent.DOM_DELTA_LINE })
expect(owner.getScrollTop()).toBe(159.5)
wheel(owner.scene, 1, { deltaMode: WheelEvent.DOM_DELTA_PAGE })
expect(owner.getScrollTop()).toBe(659.5)
wheel(owner.scene, 120, { ctrlKey: true })
wheel(owner.scene, 0, { deltaX: 120 })
const consumed = (event: WheelEvent): void => event.preventDefault()
owner.scene.addEventListener('wheel', consumed)
wheel(owner.scene, 120)
owner.scene.removeEventListener('wheel', consumed)
expect(owner.getScrollTop()).toBe(659.5)
const detach = owner.mount(view.host)
detach()
wheel(owner.scene, 120)
expect(owner.getScrollTop()).toBe(659.5)
owner.mount(view.host)
wheel(owner.scene, 120)
expect(owner.getScrollTop()).toBe(779.5)
owner.input(-10000)
expect(wheel(owner.scene, -120).defaultPrevented).toBe(false)
expect(owner.getScrollTop()).toBe(0)
} finally {
view.close()
}
})
it('yields to nested scrolling and containment, chaining outward only at an inner boundary', async () => {
const view = viewport()
const { owner } = view
const textarea = document.createElement('textarea')
textarea.style.overflowY = 'auto'
Object.defineProperties(textarea, {
scrollHeight: { value: 500 },
clientHeight: { value: 100 }
})
owner.scene.append(textarea)
try {
owner.setItems([row('first', 0, 10000)])
await commit()
textarea.scrollTop = 50
expect(wheel(textarea, 120).defaultPrevented).toBe(false)
expect(owner.getScrollTop()).toBe(0)
textarea.scrollTop = 400
expect(wheel(textarea, 120).defaultPrevented).toBe(true)
expect(owner.getScrollTop()).toBe(120)
textarea.style.overscrollBehaviorY = 'contain'
expect(wheel(textarea, 120).defaultPrevented).toBe(false)
expect(owner.getScrollTop()).toBe(120)
textarea.style.overscrollBehaviorY = 'auto'
textarea.scrollTop = 0
wheel(textarea, -7.5)
expect(owner.getScrollTop()).toBe(112.5)
const horizontal = document.createElement('div')
horizontal.style.overflow = 'auto'
Object.defineProperties(horizontal, {
scrollWidth: { value: 500 },
clientWidth: { value: 100 }
})
owner.scene.append(horizontal)
horizontal.scrollLeft = 50
expect(wheel(horizontal, 7.5, { deltaX: 120 }).defaultPrevented).toBe(false)
expect(owner.getScrollTop()).toBe(112.5)
horizontal.scrollLeft = 400
expect(wheel(horizontal, 7.5, { deltaX: 120 }).defaultPrevented).toBe(true)
expect(owner.getScrollTop()).toBe(120)
horizontal.style.overscrollBehaviorX = 'contain'
expect(wheel(horizontal, 7.5, { deltaX: 120 }).defaultPrevented).toBe(false)
expect(owner.getScrollTop()).toBe(120)
} finally {
view.close()
}
})
it('keeps pane shift-wheel horizontal and yields wrapped-pane gestures to the outer owner', async () => {
const view = viewport()
const { owner } = view
const pane = document.createElement('div')
owner.scene.append(pane)
let horizontal = 0
let scrollWidth = 1200
const editor = {
getContainerDomNode: () => pane,
getScrollLeft: () => horizontal,
setScrollLeft: (value: number) => {
horizontal = value
},
getScrollWidth: () => scrollWidth,
getLayoutInfo: () => ({ contentWidth: 500 })
}
const cleanup = installDiffEditorShiftWheelScroll({
getOriginalEditor: () => editor,
getModifiedEditor: () => editor
})
try {
owner.setItems([row('first', 0, 10000)])
await commit()
wheel(pane, 120, { shiftKey: true })
expect(horizontal).toBe(120)
expect(owner.getScrollTop()).toBe(0)
scrollWidth = 500
wheel(pane, 120, { shiftKey: true })
expect(horizontal).toBe(120)
expect(owner.getScrollTop()).toBe(120)
} finally {
cleanup()
view.close()
}
})
@@ -1,5 +1,6 @@
import { Scrollable } from 'monaco-editor/esm/vs/base/common/scrollable.js'
import { SmoothScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js'
import { handleCombinedDiffWheel } from './combined-diff-wheel-input'
import { CombinedDiffExtentIndex } from './combined-diff-extent-index'
import type { DiffItemLayout, DiffViewportLayout } from './combined-diff-layout'
import type { DiffViewportItem } from './combined-diff-viewport-owner'
@@ -50,7 +51,7 @@ export class CombinedDiffViewportScene {
})
this.scrollbar = new SmoothScrollableElement(
this.root,
{ vertical: 1, horizontal: 2, useShadows: false },
{ vertical: 1, horizontal: 2, useShadows: false, handleMouseWheel: false },
this.scrollable
)
this.scrollable.onScroll(({ scrollTop }) => {
@@ -61,6 +62,7 @@ export class CombinedDiffViewportScene {
this.callbacks.scrollTo(target)
})
this.root.addEventListener('scroll', this.forwardNativeScroll)
this.root.addEventListener('wheel', this.onWheel, { passive: false })
this.root.addEventListener('keydown', this.onKeyDown)
this.root.addEventListener('focusin', this.callbacks.focusChanged)
this.root.addEventListener('focusout', this.callbacks.focusChanged)
@@ -232,6 +234,11 @@ export class CombinedDiffViewportScene {
event.preventDefault()
this.callbacks.scrollBy(delta)
}
private onWheel = (event: WheelEvent): void => {
if (this.mounted && !this.disposed) {
handleCombinedDiffWheel(event, this.root, this.height, this.layout, this.callbacks.scrollBy)
}
}
private forwardNativeScroll = (): void => {
const delta = this.root.scrollTop
if (!delta && !this.root.scrollLeft) {
@@ -245,6 +252,7 @@ export class CombinedDiffViewportScene {
this.disposed = true
this.observer?.disconnect()
this.root.removeEventListener('scroll', this.forwardNativeScroll)
this.root.removeEventListener('wheel', this.onWheel)
this.root.removeEventListener('keydown', this.onKeyDown)
this.root.removeEventListener('focusin', this.callbacks.focusChanged)
this.root.removeEventListener('focusout', this.callbacks.focusChanged)
@@ -0,0 +1,60 @@
import { getWheelScrollDeltaY } from '@/lib/wheel-scroll-delta'
import type { DiffViewportLayout } from './combined-diff-layout'
export function handleCombinedDiffWheel(
event: WheelEvent,
root: HTMLElement,
height: number,
layout: DiffViewportLayout,
scrollBy: (delta: number) => void
): void {
if (event.defaultPrevented || event.ctrlKey) {
return
}
const delta = getWheelScrollDeltaY(event, height)
if (delta === 0 || descendantOwnsWheel(event, root, delta)) {
return
}
const min = -layout.leadingSlack
const max = Math.max(0, layout.logicalHeight - height) + layout.trailingSlack
const next = Math.max(min, Math.min(layout.logicalTop + delta, max))
if (next !== layout.logicalTop) {
event.preventDefault()
scrollBy(delta)
}
}
function descendantOwnsWheel(event: WheelEvent, root: HTMLElement, delta: number): boolean {
for (const node of event.composedPath()) {
if (node === root) {
break
}
if (!(node instanceof HTMLElement)) {
continue
}
const style = getComputedStyle(node)
if (event.deltaX !== 0 && (style.overflowX === 'auto' || style.overflowX === 'scroll')) {
const extent = Math.max(0, node.scrollWidth - node.clientWidth)
const min = style.direction === 'rtl' ? -extent : 0
const max = style.direction === 'rtl' ? 0 : extent
if (
(event.deltaX < 0 ? node.scrollLeft > min : node.scrollLeft < max) ||
style.overscrollBehaviorX === 'contain' ||
style.overscrollBehaviorX === 'none'
) {
return true
}
}
if (style.overflowY !== 'auto' && style.overflowY !== 'scroll') {
continue
}
const max = Math.max(0, node.scrollHeight - node.clientHeight)
if (
(delta < 0 ? node.scrollTop > 0 : node.scrollTop < max) ||
style.overscrollBehaviorY === 'contain' ||
style.overscrollBehaviorY === 'none'
) {
return true
}
}
return false
}
@@ -21,7 +21,12 @@ declare module 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement
export class SmoothScrollableElement {
constructor(
element: HTMLElement,
options: { vertical: number; horizontal: number; useShadows: boolean },
options: {
vertical: number
horizontal: number
useShadows: boolean
handleMouseWheel?: boolean
},
scrollable: Scrollable
)
getDomNode(): HTMLElement