diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-anchor.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-anchor.ts index 2d56ef3c872..0896ae9ac4c 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-anchor.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-anchor.ts @@ -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() } diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-input.test.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-input.test.ts new file mode 100644 index 00000000000..26c5b54ff74 --- /dev/null +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-input.test.ts @@ -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 { + 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() + } +}) diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-scene.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-scene.ts index ed5c7a4e1fc..35ccc734de5 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-scene.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-scene.ts @@ -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) diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-wheel-input.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-wheel-input.ts new file mode 100644 index 00000000000..ca947a08bca --- /dev/null +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-wheel-input.ts @@ -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 +} diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/monaco-scrollable.d.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/monaco-scrollable.d.ts index 32288a0cebd..2fb3c4ef560 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/monaco-scrollable.d.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/monaco-scrollable.d.ts @@ -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