From 206d5b1d3125d419857eb4e22cd91ec6870bd2c3 Mon Sep 17 00:00:00 2001 From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com> Date: Wed, 11 Nov 2026 07:58:41 -0800 Subject: [PATCH] fix(diffs): preserve note navigation and current reading bindings --- .../diff-comment-scroll-command.test.tsx | 248 ++++++++++++++++++ .../diff-comment-scroll-command.ts | 60 +++++ .../diff-comment-scroll.test-fixture.ts | 220 ++++++++++++++++ .../diff-comment-zone-geometry.ts | 105 ++++++-- .../diff-comments/useDiffCommentDecorator.tsx | 8 +- .../scroll-viewport/CombinedDiffViewport.tsx | 22 +- .../combined-diff-editor-geometry.ts | 13 +- .../combined-diff-native-anchor.ts | 17 +- .../combined-diff-native-binding.ts | 2 +- .../combined-diff-native-reveal.test.ts | 47 ++++ .../combined-diff-native.test-fixture.ts | 6 + .../combined-diff-row-chrome.ts | 58 +++- .../combined-diff-row-content.test.ts | 114 ++++++++ .../combined-diff-viewport-anchor.ts | 61 ++++- .../combined-diff-viewport-owner.ts | 15 +- .../editor/diff/monaco-view/DiffViewer.tsx | 4 +- .../editor/diff/sections/DiffSectionItem.tsx | 4 +- .../diff-comments/diff-comment-persistence.ts | 18 +- .../slices/diff-comments/diffComments.test.ts | 10 + 19 files changed, 947 insertions(+), 85 deletions(-) create mode 100644 src/renderer/src/components/diff-comments/diff-comment-scroll-command.test.tsx create mode 100644 src/renderer/src/components/diff-comments/diff-comment-scroll-command.ts create mode 100644 src/renderer/src/components/diff-comments/diff-comment-scroll.test-fixture.ts create mode 100644 src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-content.test.ts diff --git a/src/renderer/src/components/diff-comments/diff-comment-scroll-command.test.tsx b/src/renderer/src/components/diff-comments/diff-comment-scroll-command.test.tsx new file mode 100644 index 00000000000..a7e09e00b3d --- /dev/null +++ b/src/renderer/src/components/diff-comments/diff-comment-scroll-command.test.tsx @@ -0,0 +1,248 @@ +// @vitest-environment happy-dom +import { act, renderHook } from '@testing-library/react' +import { afterEach, expect, it, vi } from 'vitest' +import { useAppStore } from '@/store' +import { consumeDiffCommentScrollCommand } from './diff-comment-scroll-command' +import { + createScrollCommandFixture, + flushScrollCommand, + scrollNote +} from './diff-comment-scroll.test-fixture' + +vi.mock('monaco-editor', () => import('monaco-editor/esm/vs/editor/editor.api.js')) +vi.mock('../right-sidebar/source-control/panel/worktree-scope', () => ({ + useSourceControlScope: () => null, + sourceControlScopeRuntimeEnvironmentId: () => undefined +})) +afterEach(() => { + useAppStore.getState().setScrollToDiffCommentId(null) + vi.unstubAllGlobals() +}) + +it('cancels through the real owner and accepts the actual batched same-note opener without stale consumption', async () => { + const fixture = createScrollCommandFixture() + const surface = fixture.bindEditor() + const hook = renderHook(() => fixture.useSurface(surface)) + try { + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + const canceled = fixture.combinedScrollRequestRef.current! + expect(canceled.isCurrent()).toBe(true) + await act(async () => { + fixture.owner.input(0) + surface.navigation.zoneMeasured(scrollNote.id) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + expect(fixture.combinedScrollRequestRef.current).toBeNull() + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + const old = fixture.combinedScrollRequestRef.current! + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + old.consume(() => { + throw new Error('Old same-note callback consumed successor') + }) + old.cancel() + expect(useAppStore.getState().scrollToDiffCommentId).toBe('note') + expect(fixture.combinedScrollRequestRef.current).not.toBe(old) + await flushScrollCommand() + }) + const current = fixture.combinedScrollRequestRef.current! + await act(async () => { + useAppStore.getState().setScrollToDiffCommentId('different') + current.consume(() => { + throw new Error('Old callback consumed different note') + }) + current.cancel() + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBe('different') + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + canceled.cancel() + fixture.setReady(true) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + expect(fixture.owner.getScrollTop()).toBe(700) + } finally { + hook.unmount() + fixture.dispose() + } +}) + +it('preserves a command across native release but cancels it when input arrives during the binding gap', async () => { + const fixture = createScrollCommandFixture() + const hook = renderHook(({ surface }) => fixture.useSurface(surface), { + initialProps: { surface: fixture.bindEditor() } + }) + try { + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + const old = fixture.combinedScrollRequestRef.current! + await act(async () => { + fixture.owner.releaseItemNavigation(fixture.item) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBe('note') + expect(fixture.combinedScrollRequestRef.current).toBeNull() + await act(async () => { + fixture.owner.input(0) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + hook.rerender({ surface: fixture.bindEditor() }) + expect(fixture.combinedScrollRequestRef.current).toBeNull() + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + await act(async () => { + fixture.owner.releaseItemNavigation(fixture.item) + await flushScrollCommand() + }) + hook.rerender({ surface: fixture.bindEditor() }) + expect(fixture.combinedScrollRequestRef.current).not.toBeNull() + await act(async () => { + old.consume(() => { + throw new Error('Released binding consumed a new attempt') + }) + fixture.setReady(true) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + expect(fixture.owner.getScrollTop()).toBe(700) + } finally { + hook.unmount() + fixture.dispose() + } +}) + +it('keeps a superseded single-file frame from consuming the newer same-note opening', async () => { + const frames: FrameRequestCallback[] = [] + vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => frames.push(callback)) + vi.stubGlobal('cancelAnimationFrame', () => {}) + const fixture = createScrollCommandFixture() + const surface = fixture.bindEditor(false) + const hook = renderHook(() => fixture.useSurface(surface)) + try { + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + const oldFrame = frames.at(-1)! + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + oldFrame(0) + expect(useAppStore.getState().scrollToDiffCommentId).toBe('note') + await flushScrollCommand() + }) + await act(async () => { + frames.at(-1)!(0) + await flushScrollCommand() + }) + expect(surface.editor.getScrollTop()).toBe(580) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + } finally { + hook.unmount() + fixture.dispose() + } +}) + +it('keeps note navigation through an overlay-only rebuild and releases actual zone lifetimes', async () => { + const fixture = createScrollCommandFixture() + let surface: ReturnType | null = fixture.bindEditor() + const consumed = vi.fn(consumeDiffCommentScrollCommand) + const hook = renderHook( + ({ + current, + label + }: { + current: ReturnType | null + label: string + }) => fixture.useDecoratorSurface(current, label, consumed), + { initialProps: { current: surface, label: 'Add note' } } + ) + const mountCard = async (): Promise => { + await act(async () => { + await flushScrollCommand() + }) + const zone = [...surface!.fake.zones.values()][0] + expect(zone).toBeDefined() + surface!.fake.domNode.append(zone.domNode) + zone.domNode.style.padding = '0px' + const card = zone.domNode.firstElementChild + expect(card).toBeInstanceOf(HTMLElement) + Object.defineProperty(card, 'offsetHeight', { configurable: true, value: 152 }) + card!.getBoundingClientRect = () => new DOMRect(0, 0, 400, 152) + await act(async () => { + surface!.layout() + await flushScrollCommand() + }) + } + try { + await mountCard() + await act(async () => { + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBe('note') + hook.rerender({ current: surface, label: 'Add a note' }) + await act(async () => { + fixture.setReady(true) + await flushScrollCommand() + }) + expect(fixture.owner.getScrollTop()).toBe(700) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + expect(consumed.mock.calls).toEqual([['note']]) + + await act(async () => { + fixture.setReady(false) + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + hook.rerender({ current: null, label: 'Add a note' }) + expect(useAppStore.getState().scrollToDiffCommentId).toBe('note') + await act(async () => { + fixture.owner.input(0) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + surface = fixture.bindEditor() + hook.rerender({ current: surface, label: 'Add a note' }) + await mountCard() + await act(async () => { + fixture.setReady(true) + await flushScrollCommand() + }) + expect(consumed.mock.calls).toEqual([['note']]) + + await act(async () => { + fixture.setReady(false) + hook.result.current.handleOpenComment(scrollNote) + await flushScrollCommand() + }) + hook.rerender({ current: null, label: 'Add a note' }) + expect(useAppStore.getState().scrollToDiffCommentId).toBe('note') + surface = fixture.bindEditor() + hook.rerender({ current: surface, label: 'Add a note' }) + await mountCard() + await act(async () => { + fixture.setReady(true) + await flushScrollCommand() + }) + expect(useAppStore.getState().scrollToDiffCommentId).toBeNull() + expect(consumed.mock.calls).toEqual([['note'], ['note']]) + } finally { + hook.unmount() + await act(flushScrollCommand) + fixture.dispose() + } +}) diff --git a/src/renderer/src/components/diff-comments/diff-comment-scroll-command.ts b/src/renderer/src/components/diff-comments/diff-comment-scroll-command.ts new file mode 100644 index 00000000000..6d175f18e1a --- /dev/null +++ b/src/renderer/src/components/diff-comments/diff-comment-scroll-command.ts @@ -0,0 +1,60 @@ +import { useAppStore } from '@/store' +import type { DiffNavigationCommand } from '../editor/combined-diff/scroll-viewport/combined-diff-viewport-anchor' +export type DiffCommentScrollCommand = DiffNavigationCommand & { + consume(consumed?: (id: string) => void): void +} + +export function consumeDiffCommentScrollCommand(expectedId: string): void { + const state = useAppStore.getState() + if (state.scrollToDiffCommentId === expectedId) { + state.setScrollToDiffCommentId(null) + } +} + +export function createDiffCommentScrollCommand( + id: string, + releaseAttempt: () => void +): DiffCommentScrollCommand { + let active = true + let release: (() => void) | undefined = releaseAttempt + const releaseNative = (): void => { + const callback = release + release = undefined + callback?.() + } + const isCurrent = (): boolean => active && useAppStore.getState().scrollToDiffCommentId === id + const dispose = (): void => { + active = false + unsubscribe() + releaseNative() + } + const unsubscribe = useAppStore.subscribe((state) => { + if (state.scrollToDiffCommentId !== id) { + dispose() + } + }) + return { + key: id, + isCurrent, + release: releaseNative, + dispose, + cancel: () => { + const current = isCurrent() + dispose() + if (current) { + consumeDiffCommentScrollCommand(id) + } + }, + consume: (consumed) => { + if (!isCurrent()) { + return + } + dispose() + if (consumed) { + consumed(id) + } else { + consumeDiffCommentScrollCommand(id) + } + } + } +} diff --git a/src/renderer/src/components/diff-comments/diff-comment-scroll.test-fixture.ts b/src/renderer/src/components/diff-comments/diff-comment-scroll.test-fixture.ts new file mode 100644 index 00000000000..636b86f9396 --- /dev/null +++ b/src/renderer/src/components/diff-comments/diff-comment-scroll.test-fixture.ts @@ -0,0 +1,220 @@ +import { useRef } from 'react' +import { useAppStore } from '@/store' +import { createFakeDiffCommentEditor } from './diff-comment-editor-test-fixture' +import { + createDiffCommentZoneNavigation, + usePendingDiffCommentZoneReveal +} from './diff-comment-zone-geometry' +import { + consumeDiffCommentScrollCommand, + type DiffCommentScrollCommand +} from './diff-comment-scroll-command' +import type { DecoratedDiffComment } from './decorated-diff-comment' +import type { ZoneEntry } from './diff-comment-view-zone-entry' +import { CombinedDiffViewportOwner } from '../editor/combined-diff/scroll-viewport/combined-diff-viewport-owner' +import { registerCombinedEditorGeometry } from '../editor/combined-diff/scroll-viewport/combined-diff-editor-geometry' +import { useSourceControlNoteOpening } from '../right-sidebar/source-control/notes/use-note-opening' +import { useDiffCommentDecorator } from './useDiffCommentDecorator' + +export const scrollNote: DecoratedDiffComment = { + id: 'note', + worktreeId: 'workspace', + filePath: 'long.ts', + lineNumber: 40, + body: 'Review this line', + createdAt: 1, + side: 'modified' +} + +export async function flushScrollCommand(): Promise { + await Promise.resolve() + await Promise.resolve() +} + +export function createScrollCommandFixture() { + const owner = new CombinedDiffViewportOwner() + const host = document.createElement('div') + Object.defineProperties(host, { clientHeight: { value: 500 }, clientWidth: { value: 800 } }) + document.body.append(host) + const unmount = owner.mount(host) + owner.setItems([ + { + key: 'long.ts', + generation: '1', + height: 2000, + index: 0, + collapsed: false, + bodyKind: 'native' + } + ]) + const item = owner.getItem('long.ts')! + let ready = false + const unbind = owner.bind(item, { + readHeight: () => (ready ? 2000 : null), + apply: () => {}, + capture: () => null, + hasFocus: () => false, + detach: () => owner.releaseItemNavigation(item) + }) + const pendingScrollRef: { current: string | null } = { current: null } + const combinedScrollRequestRef: { current: DiffCommentScrollCommand | null } = { current: null } + const scrollToZoneFrameRef: { current: number | null } = { current: null } + const scrollToZoneRef: { current: ((id: string) => void) | null } = { current: null } + const onPendingScrollConsumedRef = { current: consumeDiffCommentScrollCommand } + const zonesRef = { current: new Map() } + const cancelScrollToZoneFrame = (): void => { + if (scrollToZoneFrameRef.current !== null) { + cancelAnimationFrame(scrollToZoneFrameRef.current) + } + scrollToZoneFrameRef.current = null + } + const releases: (() => void)[] = [] + const bindEditor = (combined = true) => { + const fake = createFakeDiffCommentEditor() + const layouts = new Set<() => void>() + const layoutInfo = fake.editor.getLayoutInfo() + let contentWidth = 0 + Object.assign(fake.editor, { + getViewZoneBounds: () => ({ hidden: false }), + getScrollWidth: () => 800, + getLayoutInfo: () => ({ ...layoutInfo, contentWidth }), + onDidLayoutChange: (listener: () => void) => { + layouts.add(listener) + return { dispose: () => layouts.delete(listener) } + }, + onDidContentSizeChange: () => ({ dispose: () => {} }) + }) + const node = document.createElement('div') + const card = document.createElement('div') + node.style.padding = '0px' + Object.defineProperty(card, 'offsetHeight', { value: 152 }) + card.getBoundingClientRect = () => new DOMRect(0, 0, 400, 152) + node.append(card) + host.append(node) + const identity = String(releases.length) + const entry: ZoneEntry = { + zoneId: 'zone', + domNode: node, + delegate: { afterLineNumber: 40, heightInPx: 152, domNode: node }, + root: { render: () => {}, unmount: () => {} }, + lifetime: new AbortController(), + disposeMouseDownStopper: () => {}, + lastRenderSignature: '', + laidOut: true + } + zonesRef.current = new Map([[scrollNote.id, entry]]) + const unregister = registerCombinedEditorGeometry(fake.editor, { + item, + identity, + onUnbind: new Set(), + registerZone: () => () => {}, + measureZone: (_id, _node, measure) => measure(), + zonePoint: (_id, zoneNode) => ({ + isValid: () => zoneNode.isConnected && !entry.lifetime.signal.aborted, + project: () => 800 - owner.getScrollTop(), + resolveScrollTop: (displacement) => 800 - displacement, + revealDisplacement: () => 100, + dispose: () => {} + }) + }) + const navigation = createDiffCommentZoneNavigation({ + editor: fake.editor, + monacoModelIdentity: identity, + zones: zonesRef.current, + combined, + pendingScrollRef, + combinedScrollRequestRef, + scrollToZoneFrameRef, + onPendingScrollConsumedRef, + cancelScrollToZoneFrame + }) + scrollToZoneRef.current = navigation.scrollToZone + releases.push(() => { + unregister() + fake.domNode.remove() + node.remove() + }) + return { + editor: fake.editor, + identity, + navigation, + fake, + layout: () => { + contentWidth = 800 + layouts.forEach((listener) => listener()) + } + } + } + function useOpening() { + const sourceControlRef = useRef(null) + return useSourceControlNoteOpening({ + activeWorktreeId: 'workspace', + worktreePath: '/workspace', + entries: [{ path: 'long.ts', area: 'unstaged', status: 'modified' }], + branchEntries: [], + branchSummary: null, + handleOpenDiff: () => {}, + openCommittedDiff: () => {}, + sourceControlRef + }) + } + function useSurface(surface: ReturnType) { + const id = useAppStore((state) => state.scrollToDiffCommentId) + const opening = useOpening() + usePendingDiffCommentZoneReveal({ + editor: surface.editor, + monacoModelIdentity: surface.identity, + comments: [scrollNote], + filePath: 'long.ts', + worktreeId: 'workspace', + pendingScrollCommentId: id, + pendingScrollRef, + combinedScrollRequestRef, + zonesRef, + scrollToZoneRef, + cancelScrollToZoneFrame + }) + return opening + } + const comments = [scrollNote] + const deleteComment = (): void => {} + function useDecoratorSurface( + surface: ReturnType | null, + addButtonLabel: string, + onConsumed: (id: string) => void + ) { + const id = useAppStore((state) => state.scrollToDiffCommentId) + const opening = useOpening() + useDiffCommentDecorator({ + editor: surface?.editor ?? null, + monacoModelIdentity: surface?.identity, + filePath: scrollNote.filePath, + worktreeId: scrollNote.worktreeId, + comments, + addButtonLabel, + onDeleteComment: deleteComment, + pendingScrollCommentId: id, + onPendingScrollConsumed: onConsumed + }) + return opening + } + return { + owner, + item, + bindEditor, + useSurface, + useDecoratorSurface, + combinedScrollRequestRef, + setReady: (value: boolean) => { + ready = value + owner.invalidate(item) + }, + dispose: () => { + unbind() + unmount() + owner.dispose() + releases.forEach((release) => release()) + host.remove() + } + } +} diff --git a/src/renderer/src/components/diff-comments/diff-comment-zone-geometry.ts b/src/renderer/src/components/diff-comments/diff-comment-zone-geometry.ts index 2597fcf489e..eebe32f9234 100644 --- a/src/renderer/src/components/diff-comments/diff-comment-zone-geometry.ts +++ b/src/renderer/src/components/diff-comments/diff-comment-zone-geometry.ts @@ -8,6 +8,11 @@ import { } from '../editor/combined-diff/scroll-viewport/combined-diff-editor-geometry' import { resizeDiffCommentZone, type ZoneEntry } from './diff-comment-view-zone-entry' import { requestDiffCommentZoneMeasurement } from './diff-comment-zone-measurement' +import { useAppStore } from '@/store' +import { + createDiffCommentScrollCommand, + type DiffCommentScrollCommand +} from './diff-comment-scroll-command' type ZoneNavigationContext = { editor: monacoEditor.ICodeEditor @@ -15,9 +20,9 @@ type ZoneNavigationContext = { zones: Map combined: boolean pendingScrollRef: RefObject - combinedScrollRequestRef: RefObject + combinedScrollRequestRef: RefObject scrollToZoneFrameRef: RefObject - onPendingScrollConsumedRef: RefObject<(() => void) | undefined> + onPendingScrollConsumedRef: RefObject<((id: string) => void) | undefined> cancelScrollToZoneFrame: () => void } @@ -67,21 +72,32 @@ export function createDiffCommentZoneNavigation({ // Combined targets are zone-local; the legacy route retains its deferred native centering. const scrollToZone = (commentId: string): void => { - cancelScrollToZoneFrame() const entry = zones.get(commentId) if ( !entry || entry.lifetime.signal.aborted || pendingScrollRef.current !== commentId || + useAppStore.getState().scrollToDiffCommentId !== commentId || !isCombinedEditorBindingCurrent(editor, monacoModelIdentity) ) { return } + if (combinedScrollRequestRef.current) { + return + } + cancelScrollToZoneFrame() if (combined) { - if (combinedScrollRequestRef.current) { - return - } measureCombinedCommentZone(editor, entry.zoneId, entry.domNode, () => { + if ( + combinedScrollRequestRef.current || + pendingScrollRef.current !== commentId || + useAppStore.getState().scrollToDiffCommentId !== commentId || + zones.get(commentId) !== entry || + entry.lifetime.signal.aborted || + !isCombinedEditorBindingCurrent(editor, monacoModelIdentity) + ) { + return false + } if (!resizeDiffCommentZone(editor, entry)) { return false } @@ -90,7 +106,16 @@ export function createDiffCommentZoneNavigation({ if (!(card instanceof HTMLElement) || card.offsetHeight <= 0) { return false } - const request = { resolved: false } + let resolved = false + const request = createDiffCommentScrollCommand(commentId, () => { + if (combinedScrollRequestRef.current === request) { + combinedScrollRequestRef.current = null + if (pendingScrollRef.current === commentId) { + pendingScrollRef.current = null + } + cancelScrollToZoneFrame() + } + }) combinedScrollRequestRef.current = request const zoneCurrent = (): boolean => zones.get(commentId) === entry && @@ -98,25 +123,25 @@ export function createDiffCommentZoneNavigation({ isCombinedEditorBindingCurrent(editor, monacoModelIdentity) const current = (): boolean => combinedScrollRequestRef.current === request && + request.isCurrent() && pendingScrollRef.current === commentId && zoneCurrent() const accepted = revealCombinedCommentZone({ editor, id: entry.zoneId, node: entry.domNode, - controls: () => (zoneCurrent() && (request.resolved || current()) ? [card] : []), + controls: () => (zoneCurrent() && (resolved || current()) ? [card] : []), + command: request, focus: () => { if (!current()) { return } - request.resolved = true - pendingScrollRef.current = null - combinedScrollRequestRef.current = null - onPendingScrollConsumedRef.current?.() + resolved = true + request.consume(onPendingScrollConsumedRef.current) } }) if (!accepted) { - combinedScrollRequestRef.current = null + request.dispose() } return accepted }) @@ -125,10 +150,19 @@ export function createDiffCommentZoneNavigation({ if (!entry.laidOut) { return } + const request = createDiffCommentScrollCommand(commentId, () => { + if (combinedScrollRequestRef.current === request) { + combinedScrollRequestRef.current = null + pendingScrollRef.current = null + cancelScrollToZoneFrame() + } + }) + combinedScrollRequestRef.current = request scrollToZoneFrameRef.current = requestAnimationFrame(() => { scrollToZoneFrameRef.current = null const entry = zones.get(commentId) - if (!entry || !editor.getModel() || entry.lifetime.signal.aborted) { + if (!entry || !editor.getModel() || entry.lifetime.signal.aborted || !request.isCurrent()) { + request.dispose() return } if (pendingScrollRef.current !== commentId) { @@ -137,8 +171,7 @@ export function createDiffCommentZoneNavigation({ const top = editor.getTopForLineNumber(entry.delegate.afterLineNumber, true) const editorHeight = editor.getLayoutInfo().height editor.setScrollTop(Math.max(0, top - editorHeight / 2)) - pendingScrollRef.current = null - onPendingScrollConsumedRef.current?.() + request.consume(onPendingScrollConsumedRef.current) }) } return { resizeZone, zoneMeasured, scrollToZone } @@ -152,7 +185,7 @@ type PendingZoneRevealContext = { worktreeId: string pendingScrollCommentId?: string | null pendingScrollRef: RefObject - combinedScrollRequestRef: RefObject + combinedScrollRequestRef: RefObject zonesRef: RefObject> scrollToZoneRef: RefObject<((commentId: string) => void) | null> cancelScrollToZoneFrame: () => void @@ -176,11 +209,14 @@ export function usePendingDiffCommentZoneReveal({ if (!editor || !isCombinedEditorBindingCurrent(editor, monacoModelIdentity)) { return } - // Cancel cleared requests so late layout callbacks cannot snap-scroll. - if (!pendingScrollCommentId) { + const clearAttempt = (): void => { cancelScrollToZoneFrame() + combinedScrollRequestRef.current?.dispose() pendingScrollRef.current = null combinedScrollRequestRef.current = null + } + if (!pendingScrollCommentId) { + clearAttempt() return } const target = comments.find( @@ -189,19 +225,30 @@ export function usePendingDiffCommentZoneReveal({ ) if (!target) { // Drop foreign requests so late layout cannot acknowledge another surface’s note. - cancelScrollToZoneFrame() - pendingScrollRef.current = null - combinedScrollRequestRef.current = null + clearAttempt() return } - if (pendingScrollRef.current !== pendingScrollCommentId) { - combinedScrollRequestRef.current = null - } - pendingScrollRef.current = pendingScrollCommentId - const entry = zonesRef.current.get(pendingScrollCommentId) - if (entry && (entry.laidOut || !isCombinedEditorBindingCurrent(editor))) { - scrollToZoneRef.current?.(pendingScrollCommentId) + const synchronize = (): void => { + if (useAppStore.getState().scrollToDiffCommentId !== pendingScrollCommentId) { + clearAttempt() + return + } + if (pendingScrollRef.current !== pendingScrollCommentId) { + clearAttempt() + } + pendingScrollRef.current = pendingScrollCommentId + const entry = zonesRef.current.get(pendingScrollCommentId) + if (entry && (entry.laidOut || !isCombinedEditorBindingCurrent(editor))) { + scrollToZoneRef.current?.(pendingScrollCommentId) + } } + const unsubscribe = useAppStore.subscribe((state, previous) => { + if (state.scrollToDiffCommentId !== previous.scrollToDiffCommentId) { + synchronize() + } + }) + synchronize() + return unsubscribe }, [ cancelScrollToZoneFrame, editor, diff --git a/src/renderer/src/components/diff-comments/useDiffCommentDecorator.tsx b/src/renderer/src/components/diff-comments/useDiffCommentDecorator.tsx index 5808048cded..6bc0fd6d0b9 100644 --- a/src/renderer/src/components/diff-comments/useDiffCommentDecorator.tsx +++ b/src/renderer/src/components/diff-comments/useDiffCommentDecorator.tsx @@ -8,6 +8,7 @@ import type { editor as monacoEditor } from 'monaco-editor' import { createRoot, type Root } from 'react-dom/client' import { invalidateCombinedEditorGeometry, + releaseCombinedEditorNavigation, isCombinedEditorBindingCurrent, onCombinedEditorUnbind } from '../editor/combined-diff/scroll-viewport/combined-diff-editor-geometry' @@ -35,6 +36,7 @@ import { } from './diff-comment-view-zone-entry' import type { DiffCommentLineRange, DiffCommentLineTarget } from './diff-comment-line-range' import { useDiffCommentDraftZone, type DiffCommentDraft } from './diff-comment-draft-zone' +import type { DiffCommentScrollCommand } from './diff-comment-scroll-command' export type { DiffCommentDraft } @@ -68,7 +70,7 @@ type DecoratorArgs = { formatCommentPrompt?: (comment: DecoratedDiffComment) => string // Pending scroll-to-note id from the sidebar; decorator reveals the line and acks so the same id can be re-requested later. pendingScrollCommentId?: string | null - onPendingScrollConsumed?: () => void + onPendingScrollConsumed?: (id: string) => void } export function useDiffCommentDecorator({ @@ -117,7 +119,7 @@ export function useDiffCommentDecorator({ // Stash the diff-zones effect's scrollToZone closure so the request-effect can invoke the latest version. const scrollToZoneRef = useRef<((commentId: string) => void) | null>(null) const scrollToZoneFrameRef = useRef(null) - const combinedScrollRequestRef = useRef(null) + const combinedScrollRequestRef = useRef(null) // Read current inline callbacks without tearing down zones on every parent render. const onDeleteCommentRef = useRef(onDeleteComment) @@ -247,6 +249,7 @@ export function useDiffCommentDecorator({ zonesRef.current = zones return onCombinedEditorUnbind(editor, () => { + releaseCombinedEditorNavigation(editor) // Clear zones synchronously; defer root unmounts until after React 19’s commit to avoid unmount-while-rendering warnings. const rootsToUnmount = Array.from(zones.values(), (z) => { z.lifetime.abort() @@ -272,6 +275,7 @@ export function useDiffCommentDecorator({ }) } cancelScrollToZoneFrame() + combinedScrollRequestRef.current?.dispose() pendingScrollRef.current = null combinedScrollRequestRef.current = null scrollToZoneRef.current = null diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/CombinedDiffViewport.tsx b/src/renderer/src/components/editor/combined-diff/scroll-viewport/CombinedDiffViewport.tsx index 2925a638ad6..044778262e4 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/CombinedDiffViewport.tsx +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/CombinedDiffViewport.tsx @@ -1,4 +1,4 @@ -import { observeCombinedDiffRowChrome } from './combined-diff-row-chrome' +import { observeCombinedDiffRowContent } from './combined-diff-row-chrome' import { createContext, useContext, @@ -59,28 +59,12 @@ function DiffViewportRow({ children: ReactNode }): React.JSX.Element { const ref = useRef(null) - useLayoutEffect( - () => observeCombinedDiffRowChrome(item, ref.current?.firstElementChild ?? null), - [item] - ) useLayoutEffect(() => { const node = ref.current! item.owner.setNode(item, node) - const observer = new ResizeObserver(() => { - if (item.binding || node.querySelector('[data-combined-diff-native]')) { - return - } - const content = node.firstElementChild - if (content instanceof HTMLElement) { - item.owner.measure(item, content.offsetHeight) - } - }) - const content = node.firstElementChild - if (content) { - observer.observe(content) - } + const stopContent = observeCombinedDiffRowContent(item, node) return () => { - observer.disconnect() + stopContent() item.owner.setNode(item, null) } }, [item]) diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-editor-geometry.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-editor-geometry.ts index 584b1260214..aee1ce279a5 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-editor-geometry.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-editor-geometry.ts @@ -1,5 +1,6 @@ import type { editor } from 'monaco-editor' import type { DiffSemanticPoint, DiffViewportItem } from './combined-diff-viewport-owner' +import type { DiffNavigationCommand } from './combined-diff-viewport-anchor' export type CombinedEditorGeometry = { readonly item: DiffViewportItem @@ -83,6 +84,13 @@ export function invalidateCombinedEditorGeometry(editor: editor.ICodeEditor): vo } } +export function releaseCombinedEditorNavigation(editor: editor.ICodeEditor): void { + const geometry = bindings.get(editor) + if (geometry) { + geometry.item.owner.releaseItemNavigation(geometry.item) + } +} + export function scrollCombinedEditorBy(editor: editor.ICodeEditor, delta: number): boolean { const geometry = bindings.get(editor) if (!geometry) { @@ -98,6 +106,7 @@ export function revealCombinedCommentZone(args: { node: HTMLElement controls: () => readonly HTMLElement[] focus?: () => void + command?: DiffNavigationCommand }): boolean { const geometry = bindings.get(args.editor) if (!geometry) { @@ -106,7 +115,9 @@ export function revealCombinedCommentZone(args: { geometry.item.owner.reveal( geometry.item, () => geometry.zonePoint(args.id, args.node, args.controls), - args.focus + args.focus, + undefined, + args.command ) return true } diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-anchor.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-anchor.ts index c7852a74518..129a7809e9c 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-anchor.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-anchor.ts @@ -45,9 +45,22 @@ export class CombinedDiffNativeAnchor { if (top >= this.item.owner.root.clientHeight || top + item.renderedHeight <= 0) { return null } - const pane = this.context.editor.getModifiedEditor() + const root = this.context.editor.getContainerDomNode().firstElementChild + return ( + this.capturePane(this.context.editor.getModifiedEditor(), edge, previous) ?? + (root?.classList.contains('side-by-side') + ? this.capturePane(this.context.editor.getOriginalEditor(), edge, previous) + : null) + ) + } + + private capturePane( + pane: editor.ICodeEditor, + edge: number, + previous?: DiffSemanticPoint + ): DiffSemanticPoint | null { const model = pane.getModel() - if (!model) { + if (!model || pane.getLayoutInfo().contentWidth <= 0) { return null } const usable = this.usableInterval(pane) diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-binding.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-binding.ts index ed398e885c2..d5b1a19a3c3 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-binding.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-binding.ts @@ -282,7 +282,7 @@ export class CombinedDiffNativeBinding implements DiffViewportBinding { return } this.template.editor.stopHiddenRegionDrag() - this.item.owner.cancelItemNavigation(this.item) + this.item.owner.releaseItemNavigation(this.item) this.record.viewState = this.template.editor.saveViewState() for (const dispose of this.onUnbind) { dispose() diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-reveal.test.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-reveal.test.ts index 75195fb9b98..f1b32010fb0 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-reveal.test.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native-reveal.test.ts @@ -319,6 +319,53 @@ describe('combined native reveal integration', () => { } }) + it.each([ + { contentWidth: 760, split: true, expectedTop: 1019 }, + { contentWidth: 0, split: true, expectedTop: 1000 }, + { contentWidth: 5, split: false, expectedTop: 1000 } + ])( + 'preserves original deletion text with applied content layout $contentWidth / $split', + async ({ contentWidth, split, expectedTop }) => { + const fixture = await createNativeBindingFixture() + fixture.setSideBySide(split) + const model = fixture.original.getModel()! + const layout = fixture.original.getLayoutInfo() + vi.spyOn(fixture.original, 'getLayoutInfo').mockReturnValue({ + ...layout, + width: contentWidth === 0 ? 40 : 800, + contentWidth + }) + vi.spyOn(fixture.modified, 'getPositionAtVerticalOffset').mockReturnValue({ + lineNumber: 1, + column: 1 + }) + try { + fixture.owner.input(1000) + model.pushEditOperations( + null, + [ + { + range: { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 }, + text: 'inserted\n' + } + ], + () => null + ) + fixture.owner.invalidate(fixture.item) + await nativeCommit() + expect(fixture.owner.getScrollTop()).toBe(expectedTop) + if (split && contentWidth > 0) { + expect( + 28 + fixture.original.getTopForPosition(54, 1) - fixture.original.getScrollTop() + ).toBe(16) + } + } finally { + vi.restoreAllMocks() + fixture.dispose() + } + } + ) + it('lets an explicit reveal supersede input queued while the viewport was detached', async () => { const fixture = await createNativeBindingFixture() const host = document.createElement('div') diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native.test-fixture.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native.test-fixture.ts index 4a40e07e41c..3ee833c60e4 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native.test-fixture.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-native.test-fixture.ts @@ -169,7 +169,12 @@ export async function createNativeBindingFixture( } const original = pane(true) const modified = pane(false) + const diffRoot = document.createElement('div') + const nativeRoot = document.createElement('div') + nativeRoot.className = 'monaco-diff-editor side-by-side' + diffRoot.append(nativeRoot) const rawDiff = { + getContainerDomNode: () => diffRoot, updateOptions: () => {}, setModel: () => {}, restoreViewState: () => {}, @@ -223,6 +228,7 @@ export async function createNativeBindingFixture( binding, modified, original, + setSideBySide: (enabled: boolean) => nativeRoot.classList.toggle('side-by-side', enabled), restoreItems, completeAlignment: () => { aligned = true diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-chrome.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-chrome.ts index 8b8483d76d2..9d2d9c6f10c 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-chrome.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-chrome.ts @@ -2,13 +2,14 @@ import type { DiffViewportItem } from './combined-diff-viewport-item' export function observeCombinedDiffRowChrome( item: DiffViewportItem, - wrapper: Element | null + wrapper: Element | null, + isCurrent: () => boolean = () => true ): () => void { let active = true let chrome: DiffViewportItem['chrome'] | null = null const heights = new Map() const resize = new ResizeObserver(() => { - if (!active) { + if (!active || !isCurrent()) { return } let changed = false @@ -24,7 +25,7 @@ export function observeCombinedDiffRowChrome( } }) const refresh = (): void => { - if (!active) { + if (!active || !isCurrent()) { return } const next: DiffViewportItem['chrome'] = { header: null, conflict: null, body: null } @@ -75,3 +76,54 @@ export function observeCombinedDiffRowChrome( } } } + +export function observeCombinedDiffRowContent( + item: DiffViewportItem, + row: HTMLElement +): () => void { + let active = true + let content: Element | null = null + let releaseContent = (): void => {} + const refresh = (): void => { + if (!active || row.firstElementChild === content) { + return + } + releaseContent() + content = row.firstElementChild + if (!content) { + releaseContent = () => {} + return + } + const current = content + let bound = true + const isCurrent = (): boolean => active && bound && row.firstElementChild === current + const stopChrome = observeCombinedDiffRowChrome(item, current, isCurrent) + const measure = (): void => { + if ( + isCurrent() && + !item.binding && + item.bodyKind !== 'native' && + current instanceof HTMLElement && + current.offsetHeight > 0 + ) { + item.owner.measure(item, current.offsetHeight) + } + } + const resize = new ResizeObserver(measure) + resize.observe(current) + measure() + releaseContent = () => { + bound = false + resize.disconnect() + stopChrome() + } + } + refresh() + const mutation = new MutationObserver(refresh) + mutation.observe(row, { childList: true }) + return () => { + active = false + mutation.disconnect() + releaseContent() + } +} diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-content.test.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-content.test.ts new file mode 100644 index 00000000000..a202987cb8e --- /dev/null +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-row-content.test.ts @@ -0,0 +1,114 @@ +// @vitest-environment happy-dom +import { expect, it, vi } from 'vitest' +import { CombinedDiffViewportOwner } from './combined-diff-viewport-owner' +import { observeCombinedDiffRowContent } from './combined-diff-row-chrome' + +it('rebinds retained content after an earlier row disappears and ignores retired observations', async () => { + const mutations: { callback: () => void; node?: Node }[] = [] + const resizes: { callback: () => void; nodes: Element[] }[] = [] + vi.stubGlobal( + 'MutationObserver', + class { + entry: (typeof mutations)[number] + constructor(callback: () => void) { + this.entry = { callback } + mutations.push(this.entry) + } + observe(node: Node): void { + this.entry.node = node + } + disconnect(): void {} + } + ) + vi.stubGlobal( + 'ResizeObserver', + class { + entry: (typeof resizes)[number] + constructor(callback: () => void) { + this.entry = { callback, nodes: [] } + resizes.push(this.entry) + } + observe(node: Element): void { + this.entry.nodes.push(node) + } + disconnect(): void {} + } + ) + const owner = new CombinedDiffViewportOwner() + const host = document.createElement('div') + Object.defineProperties(host, { + clientWidth: { value: 800 }, + clientHeight: { value: 500 } + }) + const unmount = owner.mount(host) + const commit = async (): Promise => { + await Promise.resolve() + await Promise.resolve() + } + const a = { key: 'a', generation: 'deferred', height: 200, collapsed: false, index: 0 } + const b = { ...a, key: 'b', index: 1 } + owner.setItems([a, b]) + const item = owner.getItem('b')! + const row = document.createElement('div') + const wrapper = (): { content: HTMLDivElement; header: HTMLDivElement } => { + const content = document.createElement('div') + const header = document.createElement('div') + header.setAttribute('data-combined-diff-section-header', '') + content.append(header) + return { content, header } + } + const old = wrapper() + let oldHeight = 200 + Object.defineProperty(old.content, 'offsetHeight', { get: () => oldHeight }) + row.append(old.content) + const stop = observeCombinedDiffRowContent(item, row) + try { + const stale = resizes.filter( + ({ nodes }) => nodes.includes(old.content) || nodes.includes(old.header) + ) + const rootMutation = mutations.find(({ node }) => node === row)!.callback + owner.setItems([{ ...b, index: 0 }]) + expect(owner.getItem('b')).toBe(item) + row.replaceChildren() + oldHeight = 900 + stale.forEach(({ callback }) => callback()) + await commit() + expect(owner.getLayout().logicalHeight).toBe(200) + rootMutation() + await commit() + expect(owner.getLayout().logicalHeight).toBe(200) + const next = wrapper() + let nextHeight = 320 + Object.defineProperty(next.content, 'offsetHeight', { get: () => nextHeight }) + row.append(next.content) + rootMutation() + await commit() + expect(item.chrome.header).toBe(next.header) + expect(owner.getLayout().logicalHeight).toBe(320) + oldHeight = 900 + stale.forEach(({ callback }) => callback()) + await commit() + expect(item.chrome.header).toBe(next.header) + expect(owner.getLayout().logicalHeight).toBe(320) + nextHeight = 400 + resizes.find(({ nodes }) => nodes.includes(next.content))!.callback() + await commit() + expect(owner.getLayout().logicalHeight).toBe(400) + owner.updateItems([{ ...b, index: 0, bodyKind: 'native' }]) + nextHeight = 80 + resizes.find(({ nodes }) => nodes.includes(next.content))!.callback() + await commit() + expect(owner.getLayout().logicalHeight).toBe(400) + stop() + stale.forEach(({ callback }) => callback()) + resizes.forEach(({ callback }) => callback()) + await commit() + expect(item.chrome.header).toBeNull() + expect(owner.getLayout().logicalHeight).toBe(400) + } finally { + stop() + unmount() + owner.dispose() + vi.unstubAllGlobals() + } +}) 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 a7e9647ac5d..4b15bc2427d 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 @@ -13,6 +13,13 @@ export type DiffSemanticPoint = { dispose(): void } type CommittedPoint = { point: DiffSemanticPoint; displacement: number } +export type DiffNavigationCommand = { + readonly key: string + isCurrent(): boolean + release(): void + cancel(): void + dispose(): void +} type AnchorContext = { invalidate(): void getIndex(): CombinedDiffExtentIndex @@ -32,10 +39,11 @@ export class CombinedDiffViewportAnchor { private committed: CommittedPoint | null = null private readingDirty = false private pending: { - item: DiffViewportItem - resolve: () => DiffSemanticPoint | null + item?: DiffViewportItem + resolve?: () => DiffSemanticPoint | null focus?: () => void point?: DiffSemanticPoint + command?: DiffNavigationCommand } | null = null private imported: { anchor: DiffReadingAnchor | null; fallback: number } | null = null constructor(private readonly context: AnchorContext) {} @@ -80,27 +88,53 @@ export class CombinedDiffViewportAnchor { item: DiffViewportItem, resolve: () => DiffSemanticPoint | null, focus?: () => void, - point?: DiffSemanticPoint + point?: DiffSemanticPoint, + command?: DiffNavigationCommand ): void { - this.cancelNavigation() - this.pending = { item, resolve, focus, point } + const previous = this.pending?.command + if (command && previous?.key === command.key && previous.isCurrent() && command.isCurrent()) { + this.releasePending(false) + } else { + this.cancelNavigation() + } + this.pending = { item, resolve, focus, point, command } this.context.invalidate() } cancelNavigation(): void { - this.pending?.point?.dispose() - this.pending = null this.imported = null + this.releasePending(true) } - cancelItemNavigation(item: DiffViewportItem): void { + releaseItemNavigation(item: DiffViewportItem): void { if (this.pending?.item === item) { - this.pending.point?.dispose() - this.pending = null + const command = this.pending.command + this.releasePending(false, Boolean(command)) + } + } + + private releasePending(cancel: boolean, retainCommand = false): void { + const pending = this.pending + this.pending = retainCommand && pending?.command ? { command: pending.command } : null + if (pending?.point === this.committed?.point && pending?.point) { + this.clearPoint() + } else { + pending?.point?.dispose() + } + pending?.command?.release() + if (!retainCommand) { + if (cancel) { + pending?.command?.cancel() + } else { + pending?.command?.dispose() + } } } reconcile(): (() => void) | undefined { let navigation: typeof this.pending = null + if (this.pending?.command && !this.pending.command.isCurrent()) { + this.releasePending(false) + } if (this.imported && !this.applyImport()) { return } @@ -110,16 +144,17 @@ export class CombinedDiffViewportAnchor { const pending = this.pending if ( pending && + pending.item && !pending.item.retired && pending.item.binding && pending.item.binding.readHeight() !== null ) { - const point = pending.point ?? pending.resolve() + const point = pending.point ?? pending.resolve?.() if (point) { pending.point = point } if (point?.isValid && !point.isValid()) { - this.cancelItemNavigation(pending.item) + this.releaseItemNavigation(pending.item) } else if (point) { const projected = point.project() if (projected !== null) { @@ -262,7 +297,7 @@ export class CombinedDiffViewportAnchor { this.readingDirty = false } dispose(): void { - this.cancelNavigation() + this.releasePending(false) this.clearPoint() clearTimeout(this.directionTimer) } diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-owner.ts b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-owner.ts index 651a3eb7217..2dfc7812139 100644 --- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-owner.ts +++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-viewport-owner.ts @@ -157,7 +157,7 @@ export class CombinedDiffViewportOwner { } retireItem(item: DiffViewportItem): void { - this.cancelItemNavigation(item) + this.releaseItemNavigation(item) this.geometry.forget(item) } private focusChanged(): void { @@ -215,19 +215,14 @@ export class CombinedDiffViewportOwner { this.cancelNavigation() this.anchor.preserve(point, displacement) } - reveal( - item: DiffViewportItem, - resolve: () => DiffSemanticPoint | null, - focus?: () => void, - point?: DiffSemanticPoint - ): void { - this.anchor.reveal(item, resolve, focus, point) + reveal(...args: Parameters): void { + this.anchor.reveal(...args) } cancelNavigation(): void { this.anchor.cancelNavigation() } - cancelItemNavigation(item: DiffViewportItem): void { - this.anchor.cancelItemNavigation(item) + releaseItemNavigation(item: DiffViewportItem): void { + this.anchor.releaseItemNavigation(item) } private reconcile(resetSlack = false): void { diff --git a/src/renderer/src/components/editor/diff/monaco-view/DiffViewer.tsx b/src/renderer/src/components/editor/diff/monaco-view/DiffViewer.tsx index 9af43207c3e..91129792b58 100644 --- a/src/renderer/src/components/editor/diff/monaco-view/DiffViewer.tsx +++ b/src/renderer/src/components/editor/diff/monaco-view/DiffViewer.tsx @@ -1,4 +1,5 @@ import { NO_RESOURCE_EVIDENCE } from '@/lib/workspace/ownership/workspace-copy-owner' +import { consumeDiffCommentScrollCommand } from '../../../diff-comments/diff-comment-scroll-command' import { useDiffCommentView } from '../../../diff-comments/use-diff-comment-owner' import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react' import { DiffEditor, type DiffOnMount } from '@monaco-editor/react' @@ -83,7 +84,6 @@ export default function DiffViewer({ const language = usePluginSyntaxLanguage(filePath, coreLanguage) const updateDiffComment = useAppStore((s) => s.updateDiffComment) const scrollToDiffCommentId = useAppStore((s) => s.scrollToDiffCommentId) - const setScrollToDiffCommentId = useAppStore((s) => s.setScrollToDiffCommentId) const diffComments = useMemo( () => (allDiffComments ?? []).filter((c) => c.filePath === relativePath && isDiffComment(c)), [allDiffComments, relativePath] @@ -191,7 +191,7 @@ export default function DiffViewer({ commentOwner ? updateDiffComment(commentOwner, id, body) : Promise.resolve(false) : undefined, pendingScrollCommentId: pendingScrollForThisViewer, - onPendingScrollConsumed: () => setScrollToDiffCommentId(null) + onPendingScrollConsumed: consumeDiffCommentScrollCommand }) useDiffViewerFirstChangeAutoScroll({ diff --git a/src/renderer/src/components/editor/diff/sections/DiffSectionItem.tsx b/src/renderer/src/components/editor/diff/sections/DiffSectionItem.tsx index 40cc8dd26ad..60703049942 100644 --- a/src/renderer/src/components/editor/diff/sections/DiffSectionItem.tsx +++ b/src/renderer/src/components/editor/diff/sections/DiffSectionItem.tsx @@ -1,4 +1,5 @@ import { NO_RESOURCE_EVIDENCE } from '@/lib/workspace/ownership/workspace-copy-owner' +import { consumeDiffCommentScrollCommand } from '../../../diff-comments/diff-comment-scroll-command' import { useDiffCommentView } from '../../../diff-comments/use-diff-comment-owner' import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react' import type { CombinedDiffEditorMount } from '../../combined-diff/scroll-viewport/CombinedDiffEditor' @@ -59,7 +60,6 @@ export function DiffSectionItem({ const deleteDiffComment = useAppStore((s) => s.deleteDiffComment) const updateDiffComment = useAppStore((s) => s.updateDiffComment) const scrollToDiffCommentId = useAppStore((s) => s.scrollToDiffCommentId) - const setScrollToDiffCommentId = useAppStore((s) => s.setScrollToDiffCommentId) const diffComments = useMemo( () => (allDiffComments ?? []).filter((c) => c.filePath === section.path && isDiffComment(c)), [allDiffComments, section.path] @@ -143,7 +143,7 @@ export function DiffSectionItem({ commentOwner ? updateDiffComment(commentOwner, id, body) : Promise.resolve(false) : undefined, pendingScrollCommentId: pendingScrollForThisSection, - onPendingScrollConsumed: () => setScrollToDiffCommentId(null) + onPendingScrollConsumed: consumeDiffCommentScrollCommand }) useEffect(() => { diff --git a/src/renderer/src/store/slices/diff-comments/diff-comment-persistence.ts b/src/renderer/src/store/slices/diff-comments/diff-comment-persistence.ts index 778061e1331..7edc063178e 100644 --- a/src/renderer/src/store/slices/diff-comments/diff-comment-persistence.ts +++ b/src/renderer/src/store/slices/diff-comments/diff-comment-persistence.ts @@ -165,6 +165,18 @@ export function enqueueDiffCommentPersist( } // Why: derive the next list inside the `set` updater so concurrent writes can't clobber each other via a stale closure. +function pendingAfterMutation( + id: string | null, + previous: DiffComment[] | undefined, + next: DiffComment[] +): string | null { + return id && + previous?.some((comment) => comment.id === id) && + !next.some((comment) => comment.id === id) + ? null + : id +} + export function mutateDiffComments( set: Parameters>[0], owner: DiffCommentOwner, @@ -191,6 +203,7 @@ export function mutateDiffComments( } next = computed return { + scrollToDiffCommentId: pendingAfterMutation(s.scrollToDiffCommentId, previous, computed), folderWorkspaces: s.folderWorkspaces.map((workspace) => workspace === target ? { ...workspace, diffComments: computed } : workspace ) @@ -213,7 +226,10 @@ export function mutateDiffComments( const nextList: Worktree[] = repoList.map((w) => rows.includes(w) ? { ...w, diffComments: computed } : w ) - return { worktreesByRepo: { ...s.worktreesByRepo, [repoId]: nextList } } + return { + scrollToDiffCommentId: pendingAfterMutation(s.scrollToDiffCommentId, previous, computed), + worktreesByRepo: { ...s.worktreesByRepo, [repoId]: nextList } + } }) if (next === null) { return null diff --git a/src/renderer/src/store/slices/diff-comments/diffComments.test.ts b/src/renderer/src/store/slices/diff-comments/diffComments.test.ts index daec4f004f9..a17fa639b3c 100644 --- a/src/renderer/src/store/slices/diff-comments/diffComments.test.ts +++ b/src/renderer/src/store/slices/diff-comments/diffComments.test.ts @@ -173,6 +173,16 @@ describe('bulk clear diff comments', () => { }) }) + it('retires a removed note request without consuming a request owned by another note', async () => { + const store = createTestStore() + seed(store, [makeComment({ id: 'c1' }), makeComment({ id: 'c2' })]) + store.getState().setScrollToDiffCommentId('c1') + await store.getState().deleteDiffComment(capturedOwner(store, WT), 'c2') + expect(store.getState().scrollToDiffCommentId).toBe('c1') + await store.getState().clearDiffComments(capturedOwner(store, WT)) + expect(store.getState().scrollToDiffCommentId).toBeNull() + }) + it('does not clobber a later comment array identity when rollback runs', async () => { const store = createTestStore() const comments = [makeComment({ id: 'c1' })]