mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
fix(diffs): preserve the reading edge and wheel travel
This commit is contained in:
+16
-12
@@ -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()
|
||||
}
|
||||
|
||||
+233
@@ -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()
|
||||
}
|
||||
})
|
||||
+9
-1
@@ -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)
|
||||
|
||||
+60
@@ -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
|
||||
}
|
||||
+6
-1
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user