-
- {popover && hasLineCommentAction && !renderLimit.limited && (
-
setPopover(null)}
- onSubmit={handleSubmitComment}
- />
- )}
+
{renderLimit.limited ? (
) : (
-
+
+ setPendingComment(null)}
+ onSubmitComment={handleSubmitComment}
+ />
+
)}
)
}
diff --git a/src/renderer/src/components/editor/closed-editor-tab-disposal.test.ts b/src/renderer/src/components/editor/closed-editor-tab-disposal.test.ts
index f23876fcf35..1f9e61af82c 100644
--- a/src/renderer/src/components/editor/closed-editor-tab-disposal.test.ts
+++ b/src/renderer/src/components/editor/closed-editor-tab-disposal.test.ts
@@ -1,6 +1,6 @@
import { beforeEach, describe, expect, it } from 'vitest'
import {
- diffViewStateCache,
+ diffScrollTopCache,
editorSelectionCache,
pdfViewPositionCache,
scrollTopCache
@@ -141,7 +141,7 @@ function buildScenario(): {
beforeEach(() => {
scrollTopCache.clear()
editorSelectionCache.clear()
- diffViewStateCache.clear()
+ diffScrollTopCache.clear()
pdfViewPositionCache.clear()
})
@@ -214,15 +214,15 @@ describe('disposeClosedEditorTabs', () => {
})
it('drops diff view state and preview scroll entries for closed diff tabs', () => {
- diffViewStateCache.set('tab-1', {} as never)
- diffViewStateCache.set('tab-1::pane-1', {} as never)
- diffViewStateCache.set('tab-10', {} as never)
+ diffScrollTopCache.set('tab-1', {} as never)
+ diffScrollTopCache.set('tab-1::pane-1', {} as never)
+ diffScrollTopCache.set('tab-10', {} as never)
scrollTopCache.set('tab-1:preview', 5)
scrollTopCache.set('tab-1::pane-1', 6)
disposeClosedEditorTabs(createRegistry([]), [diffTab('tab-1')])
- expect([...diffViewStateCache.keys()]).toEqual(['tab-10'])
+ expect([...diffScrollTopCache.keys()]).toEqual(['tab-10'])
expect(scrollTopCache.size).toBe(0)
})
diff --git a/src/renderer/src/components/editor/closed-editor-tab-disposal.ts b/src/renderer/src/components/editor/closed-editor-tab-disposal.ts
index ddde3a74502..07645540803 100644
--- a/src/renderer/src/components/editor/closed-editor-tab-disposal.ts
+++ b/src/renderer/src/components/editor/closed-editor-tab-disposal.ts
@@ -1,7 +1,7 @@
import type { OpenFile } from '@/store/slices/editor'
import {
editorSelectionCache,
- diffViewStateCache,
+ diffScrollTopCache,
pdfViewPositionCache,
scrollTopCache
} from '@/lib/scroll-cache'
@@ -33,7 +33,7 @@ export function disposeClosedEditorTabs(
const diffModelPathPrefixes: string[] = []
const scrollTopOwners: string[] = []
const editorSelectionOwners: string[] = []
- const diffViewStateOwners: string[] = []
+ const diffScrollTopOwners: string[] = []
const closedPdfFilePaths: string[] = []
for (const closedFile of closedFiles) {
@@ -65,8 +65,8 @@ export function disposeClosedEditorTabs(
const { originalModelPathPrefix, modifiedModelPathPrefix } =
getDiffViewerMonacoModelPathPrefixes(closedFile.id)
diffModelPathPrefixes.push(originalModelPathPrefix, modifiedModelPathPrefix)
- diffViewStateCache.delete(closedFile.id)
- diffViewStateOwners.push(closedFile.id)
+ diffScrollTopCache.delete(closedFile.id)
+ diffScrollTopOwners.push(closedFile.id)
scrollTopCache.delete(`${closedFile.id}:preview`)
scrollTopOwners.push(closedFile.id)
break
@@ -81,6 +81,6 @@ export function disposeClosedEditorTabs(
disposeUnattachedMonacoModelsByPathPrefixes(monacoRegistry, diffModelPathPrefixes)
deletePaneScopedCacheEntries(scrollTopCache, scrollTopOwners)
deletePaneScopedCacheEntries(editorSelectionCache, editorSelectionOwners)
- deletePaneScopedCacheEntries(diffViewStateCache, diffViewStateOwners)
+ deletePaneScopedCacheEntries(diffScrollTopCache, diffScrollTopOwners)
sweepClosedPdfViewPositions(pdfViewPositionCache, closedPdfFilePaths)
}
diff --git a/src/renderer/src/components/editor/combined-diff/CombinedDiffViewer.tsx b/src/renderer/src/components/editor/combined-diff/CombinedDiffViewer.tsx
index 82e7ece6cfb..93fbb32e19c 100644
--- a/src/renderer/src/components/editor/combined-diff/CombinedDiffViewer.tsx
+++ b/src/renderer/src/components/editor/combined-diff/CombinedDiffViewer.tsx
@@ -38,6 +38,7 @@ import {
import { useCombinedDiffNotesActions } from './review-controls/use-combined-diff-notes-actions'
import { useCombinedDiffSectionActions } from './review-controls/use-combined-diff-section-actions'
import { useCombinedDiffViewPreferences } from './review-controls/use-combined-diff-view-preferences'
+import { PierreDiffProviders } from '../pierre-diff/PierreDiffProviders'
export default function CombinedDiffViewer({
file,
@@ -64,9 +65,6 @@ export default function CombinedDiffViewer({
)
const activeGroupId = useAppStore((s) => s.activeGroupIdByWorktree[file.worktreeId])
const canOpenWorkspaceFileBrowserForPath = useWorkspaceFileBrowserActionPredicate(file.worktreeId)
- const isDark =
- settings?.theme === 'dark' ||
- (settings?.theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches)
const [sections, setSections] = useState
([])
const [sectionHeights, setSectionHeights] = useState>({})
@@ -196,21 +194,20 @@ export default function CombinedDiffViewer({
shouldAutoReloadFromGitStatus: entrySet.shouldAutoReloadFromGitStatus,
treeMode: entrySet.treeMode
})
- const { handleSectionSaveRef, modifiedEditorsRef, openSection, openSectionPreview } =
- useCombinedDiffSectionActions({
- activeGroupId,
- branchCompare: entrySet.branchCompare,
- canOpenWorkspaceFileBrowserForPath,
- commitCompare: entrySet.commitCompare,
- file,
- isAllMode: entrySet.isAllMode,
- isBranchMode: entrySet.isBranchMode,
- isCommitMode: entrySet.isCommitMode,
- sections,
- sectionsRef: registry.sectionsRef,
- setSectionHeights,
- setSections
- })
+ const { handleSectionSaveRef, openSection, openSectionPreview } = useCombinedDiffSectionActions({
+ activeGroupId,
+ branchCompare: entrySet.branchCompare,
+ canOpenWorkspaceFileBrowserForPath,
+ commitCompare: entrySet.commitCompare,
+ file,
+ isAllMode: entrySet.isAllMode,
+ isBranchMode: entrySet.isBranchMode,
+ isCommitMode: entrySet.isCommitMode,
+ sections,
+ sectionsRef: registry.sectionsRef,
+ setSectionHeights,
+ setSections
+ })
useCombinedDiffViewPersist({
combinedGitStatusSignature,
@@ -313,7 +310,7 @@ export default function CombinedDiffViewer({
const allSectionsCollapsed = sectionRowKeys.allSectionsCollapsed
return (
- <>
+
-
+
)
}
diff --git a/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.test.ts b/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.test.ts
index a982d6b692c..7cba626f283 100644
--- a/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.test.ts
+++ b/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.test.ts
@@ -15,8 +15,10 @@ async function flushMicrotasks(): Promise
{
}
describe('combined diff load scheduler', () => {
- it('defaults to serial section loads', async () => {
- const blockers = [deferred(), deferred()]
+ it('defaults to loading several sections in parallel', async () => {
+ // Why: the renderer highlights in a worker pool now, so fetches are no
+ // longer serialized behind per-section editor construction.
+ const blockers = [deferred(), deferred(), deferred(), deferred(), deferred()]
const started: number[] = []
const scheduler = createCombinedDiffLoadScheduler({
schedule: (callback) => callback(),
@@ -26,15 +28,18 @@ describe('combined diff load scheduler', () => {
}
})
- scheduler.request(1)
- scheduler.request(2)
- expect(started).toEqual([1])
+ for (let index = 1; index <= 5; index += 1) {
+ scheduler.request(index)
+ }
+ expect(started).toEqual([1, 2, 3, 4])
blockers[0]!.resolve()
await flushMicrotasks()
- expect(started).toEqual([1, 2])
+ expect(started).toEqual([1, 2, 3, 4, 5])
- blockers[1]!.resolve()
+ for (const blocker of blockers.slice(1)) {
+ blocker.resolve()
+ }
await flushMicrotasks()
})
diff --git a/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.ts b/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.ts
index 61c480dd716..9e35fbce155 100644
--- a/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.ts
+++ b/src/renderer/src/components/editor/combined-diff/load-sections/combined-diff-load-scheduler.ts
@@ -8,9 +8,9 @@ export type CombinedDiffLoadScheduler = {
export function createCombinedDiffLoadScheduler({
loadSection,
schedule = (callback) => queueMicrotask(callback),
- // Why: a settled section usually mounts a Monaco DiffEditor. Serializing by
- // default keeps large lockfile-style diffs from stacking render work.
- maxConcurrent = 1
+ // Why: sections now render through Pierre, which highlights in a worker pool
+ // instead of constructing an editor, so fetches no longer need serializing.
+ maxConcurrent = 4
}: {
loadSection: (index: number) => Promise
schedule?: (callback: () => void) => void
diff --git a/src/renderer/src/components/editor/combined-diff/review-controls/use-combined-diff-section-actions.ts b/src/renderer/src/components/editor/combined-diff/review-controls/use-combined-diff-section-actions.ts
index 0fa71dbf136..ba0d77cc4dc 100644
--- a/src/renderer/src/components/editor/combined-diff/review-controls/use-combined-diff-section-actions.ts
+++ b/src/renderer/src/components/editor/combined-diff/review-controls/use-combined-diff-section-actions.ts
@@ -1,6 +1,5 @@
import { useCallback, useRef } from 'react'
import type React from 'react'
-import type { editor as monacoEditor } from 'monaco-editor'
import { useAppStore } from '@/store'
import { detectLanguage } from '@/lib/language-detect'
import { joinPath } from '@/lib/path'
@@ -19,7 +18,6 @@ import type { DiffSectionItemProps } from '../../diff-section-item-props'
export type CombinedDiffSectionActions = {
handleSectionSaveRef: DiffSectionItemProps['handleSectionSaveRef']
- modifiedEditorsRef: DiffSectionItemProps['modifiedEditorsRef']
openSection: (index: number) => void
openSectionPreview: (section: DiffSection) => void
}
@@ -54,7 +52,6 @@ export function useCombinedDiffSectionActions({
const openFile = useAppStore((s) => s.openFile)
const openBranchDiff = useAppStore((s) => s.openBranchDiff)
const openCommitDiff = useAppStore((s) => s.openCommitDiff)
- const modifiedEditorsRef = useRef>(new Map())
const openSection = useCallback(
(index: number) => {
@@ -158,13 +155,13 @@ export function useCombinedDiffSectionActions({
if (!section) {
return
}
- const modifiedEditor = modifiedEditorsRef.current.get(index)
- if (!modifiedEditor && !section.dirty) {
+ if (!section.dirty) {
return
}
const sectionKey = section.key
- const content = modifiedEditor?.getValue() ?? section.modifiedContent
+ // Why: the renderer mirrors every keystroke into section state, so it is the only draft source.
+ const content = section.modifiedContent
const absolutePath = joinPath(file.filePath, section.path)
try {
const state = useAppStore.getState()
@@ -242,5 +239,5 @@ export function useCombinedDiffSectionActions({
const handleSectionSaveRef = useRef(handleSectionSave)
handleSectionSaveRef.current = handleSectionSave
- return { handleSectionSaveRef, modifiedEditorsRef, openSection, openSectionPreview }
+ return { handleSectionSaveRef, openSection, openSectionPreview }
}
diff --git a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-section-list.tsx b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-section-list.tsx
index 36e06efcf78..df8b016b967 100644
--- a/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-section-list.tsx
+++ b/src/renderer/src/components/editor/combined-diff/scroll-viewport/combined-diff-section-list.tsx
@@ -20,11 +20,9 @@ export function CombinedDiffSectionList({
isAllMode,
isBranchMode,
isCommitMode,
- isDark,
loadSection,
loadDeferredSection,
markDirectScrollInput,
- modifiedEditorsRef,
onScrollbarPointerDown,
openSection,
openSectionPreview,
@@ -49,11 +47,9 @@ export function CombinedDiffSectionList({
isAllMode: boolean
isBranchMode: boolean
isCommitMode: boolean
- isDark: boolean
loadSection: (index: number) => void
loadDeferredSection: (index: number) => void
markDirectScrollInput: () => void
- modifiedEditorsRef: DiffSectionItemProps['modifiedEditorsRef']
onScrollbarPointerDown: (event: React.PointerEvent) => void
openSection: (index: number) => void
openSectionPreview: (section: DiffSection) => void
@@ -110,7 +106,6 @@ export function CombinedDiffSectionList({
index={virtualItem.index}
isBranchMode={isBranchMode}
sideBySide={sideBySide}
- isDark={isDark}
settings={settings}
sectionHeight={sectionHeights[virtualItem.index]}
worktreeId={file.worktreeId}
@@ -136,7 +131,6 @@ export function CombinedDiffSectionList({
}
setSectionHeights={setSectionHeights}
setSections={setSections}
- modifiedEditorsRef={modifiedEditorsRef}
handleSectionSaveRef={handleSectionSaveRef}
renderHeaderTrailingContent={(section) => {
const fileNoteCount = commentCountByFilePath.get(section.path) ?? 0
diff --git a/src/renderer/src/components/editor/diff-editor-line-number-options.test.ts b/src/renderer/src/components/editor/diff-editor-line-number-options.test.ts
deleted file mode 100644
index 57d79eb8c39..00000000000
--- a/src/renderer/src/components/editor/diff-editor-line-number-options.test.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
- applyDiffEditorLineNumberOptions,
- buildDiffEditorLineNumberOptions
-} from './diff-editor-line-number-options'
-import type { editor } from 'monaco-editor'
-
-describe('buildDiffEditorLineNumberOptions', () => {
- it('hides original line numbers in inline mode', () => {
- expect(buildDiffEditorLineNumberOptions(false)).toEqual({
- original: 'off',
- modified: 'on'
- })
- })
-
- it('shows both gutters in side-by-side mode', () => {
- expect(buildDiffEditorLineNumberOptions(true)).toEqual({
- original: 'on',
- modified: 'on'
- })
- })
-})
-
-function createMockCodeEditor(initialLineNumbers: editor.LineNumbersType = 'on'): {
- editor: editor.ICodeEditor
- emitDidChangeConfiguration: () => void
- getLineNumbers: () => editor.LineNumbersType
-} {
- let lineNumbers: editor.LineNumbersType = initialLineNumbers
- const listeners = new Set<() => void>()
-
- const mockEditor = {
- getRawOptions: () => ({ lineNumbers }),
- updateOptions: ({ lineNumbers: nextLineNumbers }: { lineNumbers?: editor.LineNumbersType }) => {
- if (nextLineNumbers) {
- lineNumbers = nextLineNumbers
- }
- },
- onDidChangeConfiguration: (listener: () => void) => {
- listeners.add(listener)
- return {
- dispose: () => {
- listeners.delete(listener)
- }
- }
- }
- } as unknown as editor.ICodeEditor
-
- return {
- editor: mockEditor,
- emitDidChangeConfiguration: () => {
- listeners.forEach((listener) => listener())
- },
- getLineNumbers: () => lineNumbers
- }
-}
-
-describe('applyDiffEditorLineNumberOptions', () => {
- it('reapplies desired line number options after parent option updates and stops after dispose', () => {
- const original = createMockCodeEditor('on')
- const modified = createMockCodeEditor('on')
- const diffEditor = {
- getOriginalEditor: () => original.editor,
- getModifiedEditor: () => modified.editor
- } as unknown as editor.IStandaloneDiffEditor
-
- const disposable = applyDiffEditorLineNumberOptions(diffEditor, false)
-
- expect(original.getLineNumbers()).toBe('off')
- expect(modified.getLineNumbers()).toBe('on')
-
- original.editor.updateOptions({ lineNumbers: 'on' })
- original.emitDidChangeConfiguration()
- expect(original.getLineNumbers()).toBe('off')
-
- disposable.dispose()
- original.editor.updateOptions({ lineNumbers: 'on' })
- original.emitDidChangeConfiguration()
- expect(original.getLineNumbers()).toBe('on')
- })
-})
diff --git a/src/renderer/src/components/editor/diff-editor-line-number-options.ts b/src/renderer/src/components/editor/diff-editor-line-number-options.ts
deleted file mode 100644
index 8a4ba9da450..00000000000
--- a/src/renderer/src/components/editor/diff-editor-line-number-options.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import type { editor } from 'monaco-editor'
-
-type DiffEditorLineNumberOptions = {
- original: editor.LineNumbersType
- modified: editor.LineNumbersType
-}
-
-type Disposable = {
- dispose: () => void
-}
-
-export function buildDiffEditorLineNumberOptions(sideBySide: boolean): DiffEditorLineNumberOptions {
- return {
- original: sideBySide ? 'on' : 'off',
- modified: 'on'
- }
-}
-
-export function applyDiffEditorLineNumberOptions(
- diffEditor: editor.IStandaloneDiffEditor,
- sideBySide: boolean
-): Disposable {
- const lineNumberOptions = buildDiffEditorLineNumberOptions(sideBySide)
- const originalEditor = diffEditor.getOriginalEditor()
- const modifiedEditor = diffEditor.getModifiedEditor()
-
- const reapplyIfNeeded = (): void => {
- if (originalEditor.getRawOptions().lineNumbers !== lineNumberOptions.original) {
- originalEditor.updateOptions({ lineNumbers: lineNumberOptions.original })
- }
- if (modifiedEditor.getRawOptions().lineNumbers !== lineNumberOptions.modified) {
- modifiedEditor.updateOptions({ lineNumbers: lineNumberOptions.modified })
- }
- }
-
- // Why: Monaco 0.55 exposes only shared diff options for line numbers, so we
- // update the inner editors directly to collapse the duplicate gutter inline.
- reapplyIfNeeded()
-
- // Why: @monaco-editor/react re-applies the parent options object on every
- // component re-render, which clobbers our per-pane lineNumbers override
- // (the parent options carry lineNumbers: 'on'). Subscribe to each inner
- // editor's onDidChangeConfiguration so we can re-assert the policy on
- // every option update without racing against Monaco's internal handling.
- const originalOptionsSub = originalEditor.onDidChangeConfiguration(reapplyIfNeeded)
- const modifiedOptionsSub = modifiedEditor.onDidChangeConfiguration(reapplyIfNeeded)
-
- return {
- dispose: () => {
- originalOptionsSub.dispose()
- modifiedOptionsSub.dispose()
- }
- }
-}
diff --git a/src/renderer/src/components/editor/diff-editor-scrollbar-options.ts b/src/renderer/src/components/editor/diff-editor-scrollbar-options.ts
deleted file mode 100644
index 0891359332b..00000000000
--- a/src/renderer/src/components/editor/diff-editor-scrollbar-options.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { editor } from 'monaco-editor'
-
-const DIFF_EDITOR_SCROLLBAR_SIZE = 20
-
-// Why: diff panes are dense review surfaces; Monaco's default scrollbar is
-// too narrow to grab comfortably beside line decorations and change gutters.
-export const diffEditorScrollbarOptions = {
- verticalScrollbarSize: DIFF_EDITOR_SCROLLBAR_SIZE,
- horizontalScrollbarSize: DIFF_EDITOR_SCROLLBAR_SIZE,
- verticalSliderSize: DIFF_EDITOR_SCROLLBAR_SIZE,
- horizontalSliderSize: DIFF_EDITOR_SCROLLBAR_SIZE
-} satisfies editor.IEditorScrollbarOptions
-
-export const combinedDiffSectionScrollbarOptions = {
- ...diffEditorScrollbarOptions,
- vertical: 'hidden',
- handleMouseWheel: false
-} satisfies editor.IEditorScrollbarOptions
diff --git a/src/renderer/src/components/editor/diff-editor-whitespace-options.test.ts b/src/renderer/src/components/editor/diff-editor-whitespace-options.test.ts
deleted file mode 100644
index 793914d4799..00000000000
--- a/src/renderer/src/components/editor/diff-editor-whitespace-options.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { buildDiffEditorWhitespaceOptions } from './diff-editor-whitespace-options'
-
-describe('buildDiffEditorWhitespaceOptions', () => {
- it('ignores trim whitespace by default', () => {
- expect(buildDiffEditorWhitespaceOptions(undefined)).toEqual({ ignoreTrimWhitespace: true })
- expect(buildDiffEditorWhitespaceOptions(false)).toEqual({ ignoreTrimWhitespace: true })
- })
-
- it('includes whitespace in the diff when the preference is on', () => {
- expect(buildDiffEditorWhitespaceOptions(true)).toEqual({ ignoreTrimWhitespace: false })
- })
-})
diff --git a/src/renderer/src/components/editor/diff-editor-whitespace-options.ts b/src/renderer/src/components/editor/diff-editor-whitespace-options.ts
deleted file mode 100644
index 4c860fadeb7..00000000000
--- a/src/renderer/src/components/editor/diff-editor-whitespace-options.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import type { editor } from 'monaco-editor'
-
-export function buildDiffEditorWhitespaceOptions(
- diffShowWhitespace: boolean | undefined
-): Pick {
- return {
- // Why: Monaco defaults this to true, which hides indentation-only diffs.
- ignoreTrimWhitespace: diffShowWhitespace !== true
- }
-}
diff --git a/src/renderer/src/components/editor/diff-editor-word-wrap-options.test.ts b/src/renderer/src/components/editor/diff-editor-word-wrap-options.test.ts
deleted file mode 100644
index 9d542cae07b..00000000000
--- a/src/renderer/src/components/editor/diff-editor-word-wrap-options.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { buildDiffEditorWordWrapOptions } from './diff-editor-word-wrap-options'
-
-describe('buildDiffEditorWordWrapOptions', () => {
- it('keeps long diff lines unwrapped by default', () => {
- expect(buildDiffEditorWordWrapOptions(undefined)).toEqual({ wordWrap: 'off' })
- expect(buildDiffEditorWordWrapOptions(false)).toEqual({ wordWrap: 'off' })
- })
-
- it('enables Monaco diff word wrapping when the diff preference is on', () => {
- expect(buildDiffEditorWordWrapOptions(true)).toEqual({ wordWrap: 'on' })
- })
-})
diff --git a/src/renderer/src/components/editor/diff-editor-word-wrap-options.ts b/src/renderer/src/components/editor/diff-editor-word-wrap-options.ts
deleted file mode 100644
index c7f1e2cbea2..00000000000
--- a/src/renderer/src/components/editor/diff-editor-word-wrap-options.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import type { editor } from 'monaco-editor'
-
-export function buildDiffEditorWordWrapOptions(
- diffWordWrap: boolean | undefined
-): Pick {
- return {
- wordWrap: diffWordWrap === true ? 'on' : 'off'
- }
-}
diff --git a/src/renderer/src/components/editor/diff-model-swap-view-state.test.ts b/src/renderer/src/components/editor/diff-model-swap-view-state.test.ts
deleted file mode 100644
index 4185ab9aa35..00000000000
--- a/src/renderer/src/components/editor/diff-model-swap-view-state.test.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-// @vitest-environment happy-dom
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { editor } from 'monaco-editor'
-import { preserveDiffViewStateAcrossModelSwaps } from './diff-model-swap-view-state'
-
-type ModelListener = () => void
-
-function modelEditorFixture() {
- let willChangeListener: ModelListener = () => {}
- let didChangeListener: ModelListener = () => {}
- const disposeWillChange = vi.fn()
- const disposeDidChange = vi.fn()
- return {
- editor: {
- onWillChangeModel: (listener: ModelListener) => {
- willChangeListener = listener
- return { dispose: disposeWillChange }
- },
- onDidChangeModel: (listener: ModelListener) => {
- didChangeListener = listener
- return { dispose: disposeDidChange }
- }
- } as unknown as editor.ICodeEditor,
- fireWillChange: () => willChangeListener(),
- fireDidChange: () => didChangeListener(),
- disposeWillChange,
- disposeDidChange
- }
-}
-
-describe('diff model swap view state', () => {
- beforeEach(() => {
- vi.restoreAllMocks()
- })
-
- it('coalesces a two-sided model rotation into one view-state restore', () => {
- const original = modelEditorFixture()
- const modified = modelEditorFixture()
- const viewState = { original: {}, modified: {} } as editor.IDiffEditorViewState
- const diffEditor = {
- getOriginalEditor: () => original.editor,
- getModifiedEditor: () => modified.editor,
- getModel: () => ({ original: {}, modified: {} }),
- saveViewState: vi.fn(() => viewState),
- restoreViewState: vi.fn()
- } as unknown as editor.IStandaloneDiffEditor
- const scheduledFrames: FrameRequestCallback[] = []
- vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
- scheduledFrames.push(callback)
- return scheduledFrames.length
- })
- vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {})
-
- preserveDiffViewStateAcrossModelSwaps(diffEditor)
- original.fireWillChange()
- original.fireDidChange()
- modified.fireWillChange()
- modified.fireDidChange()
-
- expect(diffEditor.saveViewState).toHaveBeenCalledOnce()
- expect(window.cancelAnimationFrame).toHaveBeenCalledWith(1)
- scheduledFrames[1](0)
- expect(diffEditor.restoreViewState).toHaveBeenCalledOnce()
- expect(diffEditor.restoreViewState).toHaveBeenCalledWith(viewState)
- })
-
- it('cancels pending work and listeners when the editor is disposed', () => {
- const original = modelEditorFixture()
- const modified = modelEditorFixture()
- const diffEditor = {
- getOriginalEditor: () => original.editor,
- getModifiedEditor: () => modified.editor,
- saveViewState: () => ({ original: {}, modified: {} }),
- restoreViewState: vi.fn()
- } as unknown as editor.IStandaloneDiffEditor
- vi.spyOn(window, 'requestAnimationFrame').mockReturnValue(7)
- vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {})
- const subscription = preserveDiffViewStateAcrossModelSwaps(diffEditor)
-
- modified.fireWillChange()
- modified.fireDidChange()
- subscription.dispose()
-
- expect(window.cancelAnimationFrame).toHaveBeenCalledWith(7)
- expect(original.disposeWillChange).toHaveBeenCalledOnce()
- expect(original.disposeDidChange).toHaveBeenCalledOnce()
- expect(modified.disposeWillChange).toHaveBeenCalledOnce()
- expect(modified.disposeDidChange).toHaveBeenCalledOnce()
- })
-})
diff --git a/src/renderer/src/components/editor/diff-model-swap-view-state.ts b/src/renderer/src/components/editor/diff-model-swap-view-state.ts
deleted file mode 100644
index e46a1863c0d..00000000000
--- a/src/renderer/src/components/editor/diff-model-swap-view-state.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import type { IDisposable, editor } from 'monaco-editor'
-
-export function preserveDiffViewStateAcrossModelSwaps(
- diffEditor: editor.IStandaloneDiffEditor
-): IDisposable {
- let pendingViewState: editor.IDiffEditorViewState | null = null
- let restoreFrame: number | null = null
-
- const captureViewState = (): void => {
- // Why: Monaco resets cursor and scroll state when a retained editor swaps
- // models, so capture once before either diff side starts rotating.
- pendingViewState ??= diffEditor.saveViewState()
- }
- const scheduleRestore = (): void => {
- if (!pendingViewState) {
- return
- }
- if (restoreFrame !== null) {
- cancelAnimationFrame(restoreFrame)
- }
- restoreFrame = requestAnimationFrame(() => {
- restoreFrame = null
- const viewState = pendingViewState
- pendingViewState = null
- if (viewState && diffEditor.getModel()) {
- diffEditor.restoreViewState(viewState)
- }
- })
- }
-
- const originalEditor = diffEditor.getOriginalEditor()
- const modifiedEditor = diffEditor.getModifiedEditor()
- const subscriptions = [
- originalEditor.onWillChangeModel(captureViewState),
- originalEditor.onDidChangeModel(scheduleRestore),
- modifiedEditor.onWillChangeModel(captureViewState),
- modifiedEditor.onDidChangeModel(scheduleRestore)
- ]
-
- return {
- dispose: () => {
- for (const subscription of subscriptions) {
- subscription.dispose()
- }
- if (restoreFrame !== null) {
- cancelAnimationFrame(restoreFrame)
- }
- restoreFrame = null
- pendingViewState = null
- }
- }
-}
diff --git a/src/renderer/src/components/editor/diff-navigation-context.test.tsx b/src/renderer/src/components/editor/diff-navigation-context.test.tsx
index d2efce0bd36..cb64406a2a1 100644
--- a/src/renderer/src/components/editor/diff-navigation-context.test.tsx
+++ b/src/renderer/src/components/editor/diff-navigation-context.test.tsx
@@ -2,52 +2,29 @@
import { act } from 'react'
import { createRoot, type Root } from 'react-dom/client'
import { afterEach, describe, expect, it, vi } from 'vitest'
-import type { editor } from 'monaco-editor'
import {
DiffNavigationProvider,
- useDiffEditorRegistration,
+ useDiffNavigatorRegistration,
useDiffNavigation,
- type DiffEditorRegistrationContextValue,
+ type DiffNavigator,
+ type DiffNavigatorRegistrationContextValue,
type DiffNavigationContextValue
} from './diff-navigation-context'
-type FakeDiffEditor = editor.IStandaloneDiffEditor & {
- setLineChanges: (count: number) => void
- fireUpdate: () => void
- goToDiff: ReturnType
- disposeUpdate: ReturnType
- containerNode: HTMLElement
+type FakeNavigator = DiffNavigator & {
+ scrollToChange: DiffNavigator['scrollToChange'] & { mock: unknown }
}
-function createFakeEditor(initialCount: number): FakeDiffEditor {
- let count = initialCount
- let updateCallback: (() => void) | null = null
- const disposeUpdate = vi.fn(() => {
- updateCallback = null
- })
- const containerNode = document.createElement('div')
- const editor = {
- getLineChanges: () => (count > 0 ? Array.from({ length: count }, () => ({})) : []),
- goToDiff: vi.fn(),
- getContainerDomNode: () => containerNode,
- onDidUpdateDiff: (cb: () => void) => {
- updateCallback = cb
- return {
- dispose: disposeUpdate
- }
- },
- setLineChanges: (next: number) => {
- count = next
- },
- fireUpdate: () => updateCallback?.(),
- disposeUpdate,
- containerNode
- } as unknown as FakeDiffEditor
- return editor
+function createFakeNavigator(changeLines: number[]): FakeNavigator {
+ return {
+ changeLines,
+ container: document.createElement('div'),
+ scrollToChange: vi.fn()
+ } as FakeNavigator
}
let captured: DiffNavigationContextValue | null = null
-let registration: DiffEditorRegistrationContextValue | null = null
+let registration: DiffNavigatorRegistrationContextValue | null = null
let registrationRenderCount = 0
function Probe(): null {
@@ -56,7 +33,7 @@ function Probe(): null {
}
function RegistrationProbe(): null {
- registration = useDiffEditorRegistration()
+ registration = useDiffNavigatorRegistration()
registrationRenderCount += 1
return null
}
@@ -91,83 +68,107 @@ describe('DiffNavigationProvider', () => {
registrationRenderCount = 0
})
- it('exposes the change count and routes nav actions to the registered editor', () => {
+ it('exposes the change count and routes nav actions to the registered navigator', () => {
mount()
- const editor = createFakeEditor(3)
- act(() => registration?.registerDiffEditor(editor))
+ const navigator = createFakeNavigator([4, 20, 61])
+ act(() => registration?.registerDiffNavigator(navigator))
expect(captured?.changeCount).toBe(3)
act(() => captured?.goToNextDiff())
- expect(editor.goToDiff).toHaveBeenCalledWith('next')
+ expect(navigator.scrollToChange).toHaveBeenCalledWith({
+ lineNumber: 4,
+ hunkIndex: 0,
+ hunkCount: 3
+ })
- act(() => captured?.goToPreviousDiff())
- expect(editor.goToDiff).toHaveBeenCalledWith('previous')
+ act(() => captured?.goToNextDiff())
+ expect(navigator.scrollToChange).toHaveBeenLastCalledWith({
+ lineNumber: 20,
+ hunkIndex: 1,
+ hunkCount: 3
+ })
})
- it('re-renders when onDidUpdateDiff flips the count 0 -> N (count is state)', () => {
+ it('wraps the cursor at both ends', () => {
mount()
- const editor = createFakeEditor(0)
- act(() => registration?.registerDiffEditor(editor))
- expect(captured?.changeCount).toBe(0)
+ const navigator = createFakeNavigator([4, 20])
+ act(() => registration?.registerDiffNavigator(navigator))
- act(() => {
- editor.setLineChanges(2)
- editor.fireUpdate()
+ // Previous from the initial position lands on the last change.
+ act(() => captured?.goToPreviousDiff())
+ expect(navigator.scrollToChange).toHaveBeenLastCalledWith({
+ lineNumber: 20,
+ hunkIndex: 1,
+ hunkCount: 2
})
+
+ act(() => captured?.goToNextDiff())
+ expect(navigator.scrollToChange).toHaveBeenLastCalledWith({
+ lineNumber: 4,
+ hunkIndex: 0,
+ hunkCount: 2
+ })
+ })
+
+ it('does nothing when the registered navigator has no changes', () => {
+ mount()
+ const navigator = createFakeNavigator([])
+ act(() => registration?.registerDiffNavigator(navigator))
+
+ expect(captured?.changeCount).toBe(0)
+ act(() => captured?.goToNextDiff())
+ expect(navigator.scrollToChange).not.toHaveBeenCalled()
+ })
+
+ it('ignores a stale unregister for a navigator that is no longer current (identity guard)', () => {
+ mount()
+ const oldNavigator = createFakeNavigator([1])
+ const newNavigator = createFakeNavigator([2, 3, 4, 5])
+
+ // Fast-swap: new navigator registers before the old one's teardown fires.
+ act(() => registration?.registerDiffNavigator(oldNavigator))
+ act(() => registration?.registerDiffNavigator(newNavigator))
+ expect(captured?.changeCount).toBe(4)
+
+ act(() => registration?.unregisterDiffNavigator(oldNavigator))
+
+ // New navigator's count is intact and nav still routes to it.
+ expect(captured?.changeCount).toBe(4)
+ act(() => captured?.goToNextDiff())
+ expect(newNavigator.scrollToChange).toHaveBeenCalledOnce()
+ expect(oldNavigator.scrollToChange).not.toHaveBeenCalled()
+ })
+
+ it('keeps the registration context identity stable across count changes', () => {
+ mount()
+ act(() => registration?.registerDiffNavigator(createFakeNavigator([1, 2])))
expect(captured?.changeCount).toBe(2)
expect(registrationRenderCount).toBe(1)
})
- it('ignores a stale unregister for an editor that is no longer current (identity guard)', () => {
+ it('installs a capture-phase key listener on register and removes it on unregister', () => {
mount()
- const oldEditor = createFakeEditor(1)
- const newEditor = createFakeEditor(4)
+ const navigator = createFakeNavigator([2])
+ const addSpy = vi.spyOn(navigator.container, 'addEventListener')
+ const removeSpy = vi.spyOn(navigator.container, 'removeEventListener')
- // Fast-swap: new editor registers before the old one's dispose fires.
- act(() => registration?.registerDiffEditor(oldEditor))
- act(() => registration?.registerDiffEditor(newEditor))
- expect(captured?.changeCount).toBe(4)
- expect(oldEditor.disposeUpdate).toHaveBeenCalledOnce()
+ act(() => registration?.registerDiffNavigator(navigator))
+ expect(addSpy).toHaveBeenCalledWith('keydown', expect.any(Function), true)
- // A stale update from the old editor must not flip the count back: registering
- // the new editor disposed the old subscription, so its callback no longer fires.
- act(() => {
- oldEditor.setLineChanges(9)
- oldEditor.fireUpdate()
- })
- expect(captured?.changeCount).toBe(4)
-
- act(() => registration?.unregisterDiffEditor(oldEditor))
-
- // New editor's count is intact and nav still routes to it.
- expect(captured?.changeCount).toBe(4)
- act(() => captured?.goToNextDiff())
- expect(newEditor.goToDiff).toHaveBeenCalledWith('next')
- expect(oldEditor.goToDiff).not.toHaveBeenCalled()
+ act(() => registration?.unregisterDiffNavigator(navigator))
+ expect(removeSpy).toHaveBeenCalledWith('keydown', expect.any(Function), true)
})
- it('disposes the active diff update subscription when the provider unmounts', () => {
+ it('removes the key listener when the provider unmounts', () => {
mount()
- const editor = createFakeEditor(1)
- act(() => registration?.registerDiffEditor(editor))
+ const navigator = createFakeNavigator([1])
+ const removeSpy = vi.spyOn(navigator.container, 'removeEventListener')
+ act(() => registration?.registerDiffNavigator(navigator))
act(() => root?.unmount())
- expect(editor.disposeUpdate).toHaveBeenCalledOnce()
+ expect(removeSpy).toHaveBeenCalledWith('keydown', expect.any(Function), true)
root = null
})
-
- it('installs a capture-phase key listener on register and removes it on unregister', () => {
- mount()
- const editor = createFakeEditor(2)
- const addSpy = vi.spyOn(editor.containerNode, 'addEventListener')
- const removeSpy = vi.spyOn(editor.containerNode, 'removeEventListener')
-
- act(() => registration?.registerDiffEditor(editor))
- expect(addSpy).toHaveBeenCalledWith('keydown', expect.any(Function), true)
-
- act(() => registration?.unregisterDiffEditor(editor))
- expect(removeSpy).toHaveBeenCalledWith('keydown', expect.any(Function), true)
- })
})
diff --git a/src/renderer/src/components/editor/diff-navigation-context.tsx b/src/renderer/src/components/editor/diff-navigation-context.tsx
index 9bd1175de45..9e98d76e6a5 100644
--- a/src/renderer/src/components/editor/diff-navigation-context.tsx
+++ b/src/renderer/src/components/editor/diff-navigation-context.tsx
@@ -1,10 +1,18 @@
import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
-import type { editor } from 'monaco-editor'
-import { installMonacoDiffChangeNavigationShortcut } from './editor-shortcuts'
+import { installDiffChangeNavigationShortcut } from './editor-shortcuts'
-export type DiffEditorRegistrationContextValue = {
- registerDiffEditor: (editor: editor.IStandaloneDiffEditor) => void
- unregisterDiffEditor: (editor: editor.IStandaloneDiffEditor) => void
+/** A mounted diff that can report its changes and scroll to one. */
+export type DiffNavigator = {
+ /** Modified-side start line of every hunk, in document order. */
+ changeLines: readonly number[]
+ scrollToChange: (args: { lineNumber: number; hunkIndex: number; hunkCount: number }) => void
+ /** Element the F7 / Shift+F7 listener attaches to. */
+ container: HTMLElement
+}
+
+export type DiffNavigatorRegistrationContextValue = {
+ registerDiffNavigator: (navigator: DiffNavigator) => void
+ unregisterDiffNavigator: (navigator: DiffNavigator) => void
}
export type DiffNavigationContextValue = {
@@ -16,10 +24,10 @@ export type DiffNavigationContextValue = {
const noop = (): void => {}
// Why: registration stays separate from changeCount so diff recomputation only
-// rerenders the header controls, not the heavy Monaco DiffViewer consumer.
-const DiffEditorRegistrationContext = createContext({
- registerDiffEditor: noop,
- unregisterDiffEditor: noop
+// rerenders the header controls, not the heavy diff consumer.
+const DiffNavigatorRegistrationContext = createContext({
+ registerDiffNavigator: noop,
+ unregisterDiffNavigator: noop
})
const DiffNavigationContext = createContext({
@@ -28,97 +36,104 @@ const DiffNavigationContext = createContext({
changeCount: 0
})
-function countChanges(diffEditor: editor.IStandaloneDiffEditor): number {
- return diffEditor.getLineChanges()?.length ?? 0
-}
-
export function DiffNavigationProvider({
children
}: {
children: React.ReactNode
}): React.JSX.Element {
- const editorRef = useRef(null)
- const updateSubRef = useRef<{ dispose: () => void } | null>(null)
- // Why: F7/Shift+F7 change navigation shares the registered editor with the
- // header buttons, so the keyboard listener lives here rather than in DiffViewer.
+ const navigatorRef = useRef(null)
const shortcutCleanupRef = useRef<(() => void) | null>(null)
+ // Why: the cursor is provider-owned because the renderer no longer tracks a
+ // "current change" of its own the way Monaco's goToDiff did.
+ const cursorRef = useRef(-1)
// Why: changeCount must be state, not a ref — the header is a sibling consumer
- // and only re-renders (enabling the buttons) when the value object identity
- // changes on the 0 -> N flip once the diff computation lands.
+ // and only re-renders (enabling the buttons) when the value identity changes.
const [changeCount, setChangeCount] = useState(0)
- const registerDiffEditor = useCallback((diffEditor: editor.IStandaloneDiffEditor) => {
- editorRef.current = diffEditor
- // Hold at most one update subscription; replace any prior editor's.
- updateSubRef.current?.dispose()
- updateSubRef.current = diffEditor.onDidUpdateDiff(() => {
- // Why: ignore updates from an editor that is no longer current so a stale
- // subscription in the fast-swap case can't write a wrong count.
- if (editorRef.current === diffEditor) {
- setChangeCount(countChanges(diffEditor))
- }
+ const goToChange = useCallback((direction: 'next' | 'previous') => {
+ const navigator = navigatorRef.current
+ if (!navigator) {
+ return
+ }
+ const total = navigator.changeLines.length
+ if (total === 0) {
+ return
+ }
+ // Why: from the initial position, `next` lands on the first change and
+ // `previous` wraps to the last — plain modulo would send both to index 0.
+ const step = direction === 'next' ? 1 : -1
+ const nextIndex =
+ cursorRef.current === -1
+ ? direction === 'next'
+ ? 0
+ : total - 1
+ : (((cursorRef.current + step) % total) + total) % total
+ cursorRef.current = nextIndex
+ navigator.scrollToChange({
+ lineNumber: navigator.changeLines[nextIndex],
+ hunkIndex: nextIndex,
+ hunkCount: total
})
- // Hold at most one keyboard listener; replace any prior editor's.
- shortcutCleanupRef.current?.()
- shortcutCleanupRef.current = installMonacoDiffChangeNavigationShortcut(diffEditor)
- setChangeCount(countChanges(diffEditor))
}, [])
- const unregisterDiffEditor = useCallback((diffEditor: editor.IStandaloneDiffEditor) => {
- // Why: identity guard for the fast-swap race — a stale dispose carrying the
- // old editor must not wipe a freshly-registered new one.
- if (editorRef.current !== diffEditor) {
+ const registerDiffNavigator = useCallback(
+ (navigator: DiffNavigator) => {
+ navigatorRef.current = navigator
+ cursorRef.current = -1
+ // Hold at most one keyboard listener; replace any prior navigator's.
+ shortcutCleanupRef.current?.()
+ shortcutCleanupRef.current = installDiffChangeNavigationShortcut(
+ navigator.container,
+ goToChange
+ )
+ setChangeCount(navigator.changeLines.length)
+ },
+ [goToChange]
+ )
+
+ const unregisterDiffNavigator = useCallback((navigator: DiffNavigator) => {
+ // Why: identity guard for the fast-swap race — a stale teardown carrying the
+ // old navigator must not wipe a freshly-registered new one.
+ if (navigatorRef.current !== navigator) {
return
}
- updateSubRef.current?.dispose()
- updateSubRef.current = null
shortcutCleanupRef.current?.()
shortcutCleanupRef.current = null
- editorRef.current = null
+ navigatorRef.current = null
+ cursorRef.current = -1
setChangeCount(0)
}, [])
- const goToPreviousDiff = useCallback(() => {
- editorRef.current?.goToDiff('previous')
- }, [])
-
- const goToNextDiff = useCallback(() => {
- editorRef.current?.goToDiff('next')
- }, [])
+ const goToPreviousDiff = useCallback(() => goToChange('previous'), [goToChange])
+ const goToNextDiff = useCallback(() => goToChange('next'), [goToChange])
useEffect(() => {
return () => {
- updateSubRef.current?.dispose()
- updateSubRef.current = null
shortcutCleanupRef.current?.()
shortcutCleanupRef.current = null
}
}, [])
const registrationValue = useMemo(
- () => ({ registerDiffEditor, unregisterDiffEditor }),
- [registerDiffEditor, unregisterDiffEditor]
+ () => ({ registerDiffNavigator, unregisterDiffNavigator }),
+ [registerDiffNavigator, unregisterDiffNavigator]
)
const navigationValue = useMemo(
- () => ({
- goToPreviousDiff,
- goToNextDiff,
- changeCount
- }),
+ () => ({ goToPreviousDiff, goToNextDiff, changeCount }),
[goToPreviousDiff, goToNextDiff, changeCount]
)
return (
-
+
{children}
-
+
)
}
-export function useDiffEditorRegistration(): DiffEditorRegistrationContextValue {
- return useContext(DiffEditorRegistrationContext)
+export function useDiffNavigatorRegistration(): DiffNavigatorRegistrationContextValue {
+ return useContext(DiffNavigatorRegistrationContext)
}
export function useDiffNavigation(): DiffNavigationContextValue {
diff --git a/src/renderer/src/components/editor/diff-section-item-props.ts b/src/renderer/src/components/editor/diff-section-item-props.ts
index e5ef73860c2..76e2c7c5e99 100644
--- a/src/renderer/src/components/editor/diff-section-item-props.ts
+++ b/src/renderer/src/components/editor/diff-section-item-props.ts
@@ -1,5 +1,4 @@
import type { Dispatch, MutableRefObject, ReactNode, SetStateAction } from 'react'
-import type { editor as monacoEditor } from 'monaco-editor'
import type { DecoratedDiffComment } from '../diff-comments/decorated-diff-comment'
import type { DiffSection } from './diff-section-types'
@@ -8,10 +7,11 @@ export type DiffSectionItemProps = {
index: number
isBranchMode: boolean
sideBySide: boolean
- isDark: boolean
settings: {
+ theme?: 'system' | 'dark' | 'light'
terminalFontSize?: number
terminalFontFamily?: string
+ editorFontFamily?: string
diffWordWrap?: boolean
diffShowWhitespace?: boolean
} | null
@@ -35,6 +35,5 @@ export type DiffSectionItemProps = {
getCommentableLineNumbers?: (section: DiffSection) => readonly number[] | undefined
setSectionHeights: Dispatch>>
setSections: Dispatch>
- modifiedEditorsRef: MutableRefObject>
handleSectionSaveRef: MutableRefObject<(index: number) => Promise>
}
diff --git a/src/renderer/src/components/editor/diff-section-live-render-limit.ts b/src/renderer/src/components/editor/diff-section-live-render-limit.ts
index 01e6729fc84..2a4ad6ba1e4 100644
--- a/src/renderer/src/components/editor/diff-section-live-render-limit.ts
+++ b/src/renderer/src/components/editor/diff-section-live-render-limit.ts
@@ -1,4 +1,3 @@
-import type { editor as monacoEditor } from 'monaco-editor'
import type { DiffSection } from './diff-section-types'
import {
getLargeDiffRenderLimitFromCounts,
@@ -7,19 +6,13 @@ import {
export function getLiveDiffSectionRenderLimit({
section,
- modifiedEditor,
modifiedContent
}: {
section: DiffSection
- modifiedEditor: monacoEditor.ICodeEditor
modifiedContent: string
}): LargeDiffRenderLimit {
- const modifiedLineCount =
- modifiedContent.length === 0
- ? 0
- : (modifiedEditor.getModel()?.getLineCount() ??
- section.largeDiffRenderLimit?.lineCounts?.modified ??
- 0)
+ // Why: the renderer no longer owns a text model, so count lines from the draft itself.
+ const modifiedLineCount = modifiedContent.length === 0 ? 0 : modifiedContent.split('\n').length
return getLargeDiffRenderLimitFromCounts({
originalLineCount: section.largeDiffRenderLimit?.lineCounts?.original ?? 0,
diff --git a/src/renderer/src/components/editor/editor-shortcuts.test.ts b/src/renderer/src/components/editor/editor-shortcuts.test.ts
index b8dd4cc1c48..7e5c6dc7b14 100644
--- a/src/renderer/src/components/editor/editor-shortcuts.test.ts
+++ b/src/renderer/src/components/editor/editor-shortcuts.test.ts
@@ -20,7 +20,7 @@ vi.mock('@/store', () => ({
import {
installEditorAddReviewNoteShortcut,
installEditorFindShortcut,
- installMonacoDiffChangeNavigationShortcut,
+ installDiffChangeNavigationShortcut,
installMonacoEditorFindShortcut,
installOpenDraftAddReviewNoteGuard
} from './editor-shortcuts'
@@ -315,7 +315,7 @@ describe('installOpenDraftAddReviewNoteGuard', () => {
})
})
-describe('installMonacoDiffChangeNavigationShortcut', () => {
+describe('installDiffChangeNavigationShortcut', () => {
function createDiffNavigationFixture(): {
container: HTMLDivElement
dispose: () => void
@@ -333,10 +333,7 @@ describe('installMonacoDiffChangeNavigationShortcut', () => {
return {
container,
- dispose: installMonacoDiffChangeNavigationShortcut({
- getContainerDomNode: () => container,
- goToDiff
- }),
+ dispose: installDiffChangeNavigationShortcut(container, goToDiff),
input,
goToDiff,
onDownstreamKeyDown
diff --git a/src/renderer/src/components/editor/editor-shortcuts.ts b/src/renderer/src/components/editor/editor-shortcuts.ts
index d3ae6353e41..76db195875b 100644
--- a/src/renderer/src/components/editor/editor-shortcuts.ts
+++ b/src/renderer/src/components/editor/editor-shortcuts.ts
@@ -46,13 +46,9 @@ export function installEditorFindShortcut(target: HTMLElement, onFind: () => voi
return () => target.removeEventListener('keydown', handleKeyDown, true)
}
-type MonacoDiffNavigationEditor = {
- getContainerDomNode: () => HTMLElement
- goToDiff: (target: 'next' | 'previous') => void
-}
-
-export function installMonacoDiffChangeNavigationShortcut(
- editor: MonacoDiffNavigationEditor
+export function installDiffChangeNavigationShortcut(
+ target: HTMLElement,
+ goToDiff: (direction: 'next' | 'previous') => void
): () => void {
const handleKeyDown = (event: KeyboardEvent): void => {
let direction: 'next' | 'previous' | null = null
@@ -64,17 +60,15 @@ export function installMonacoDiffChangeNavigationShortcut(
if (!direction) {
return
}
- // Why: capture-phase preventDefault/stopPropagation beats Monaco's built-in
- // F7 accessible-review pane, like the find shortcut does for Cmd+F.
+ // Why: capture-phase so the renderer's own F7 handling never sees it first.
event.preventDefault()
event.stopPropagation()
// Consume matched repeats but navigate once per press (matches find shortcut).
if (!event.repeat) {
- editor.goToDiff(direction)
+ goToDiff(direction)
}
}
- const target = editor.getContainerDomNode()
target.addEventListener('keydown', handleKeyDown, true)
return () => target.removeEventListener('keydown', handleKeyDown, true)
}
diff --git a/src/renderer/src/components/editor/pierre-diff/PierreDiffProviders.tsx b/src/renderer/src/components/editor/pierre-diff/PierreDiffProviders.tsx
new file mode 100644
index 00000000000..1cae8616d5f
--- /dev/null
+++ b/src/renderer/src/components/editor/pierre-diff/PierreDiffProviders.tsx
@@ -0,0 +1,19 @@
+import { PierreDiffWorkerPoolProvider } from './pierre-diff-worker-pool'
+import { PierreDiffEditProvider } from './pierre-diff-editor-provider'
+
+/**
+ * Wraps a diff surface with the Shiki worker pool and the editor factory.
+ * Pierre reference-counts the pool, so every diff view can mount this and they
+ * still share one set of workers.
+ */
+export function PierreDiffProviders({
+ children
+}: {
+ children: React.ReactNode
+}): React.JSX.Element {
+ return (
+
+ {children}
+
+ )
+}
diff --git a/src/renderer/src/components/editor/pierre-diff/PierreDiffSurface.tsx b/src/renderer/src/components/editor/pierre-diff/PierreDiffSurface.tsx
new file mode 100644
index 00000000000..9d9c594be5f
--- /dev/null
+++ b/src/renderer/src/components/editor/pierre-diff/PierreDiffSurface.tsx
@@ -0,0 +1,155 @@
+import { useCallback, useMemo } from 'react'
+import { FileDiff } from '@pierre/diffs/react'
+import type { FileDiffMetadata, PostRenderPhase, SelectedLineRange } from '@pierre/diffs'
+import type { FileContents } from '@pierre/diffs'
+import type { EditorOptions } from '@pierre/diffs/edit'
+import { useAppStore } from '@/store'
+import type { DecoratedDiffComment } from '../../diff-comments/decorated-diff-comment'
+import { buildPierreDiffOptions, buildPierreDiffStyle } from './pierre-diff-options'
+import type { PierreDiffSettings } from './pierre-diff-options'
+import {
+ buildPierreDiffCommentAnnotations,
+ renderPierreDiffCommentAnnotation,
+ type PierreDiffAnnotationData,
+ type PierreDiffCommentAnnotation
+} from './pierre-diff-comment-annotations'
+import { usePierreDiffFind } from './use-pierre-diff-find'
+
+export type PierreDiffSurfaceProps = {
+ fileDiff: FileDiffMetadata
+ sideBySide: boolean
+ settings?: PierreDiffSettings | null
+ isEditable: boolean
+ worktreeId: string
+ filePath: string
+ comments: readonly DecoratedDiffComment[]
+ formatCommentPrompt?: (comment: DecoratedDiffComment) => string
+ onDeleteComment: (commentId: string) => void
+ onUpdateComment?: (commentId: string, body: string) => Promise
+ /** Live document stream while an edit session is active. */
+ onEditChange?: (file: FileContents) => void
+ /** Fires on Pierre's DOM lifecycle; used for height measurement. */
+ onPostRender?: (node: HTMLElement, phase: PostRenderPhase) => void
+ /** Gutter affordance for starting a note; omit to hide it. */
+ onAddComment?: (range: { lineNumber: number; startLine?: number }) => void
+ /** Open note draft, rendered inline on its anchor line. */
+ pendingComment?: { lineNumber: number; startLine?: number } | null
+ addCommentPlaceholder?: string
+ addCommentLabel?: string
+ onCancelComment?: () => void
+ onSubmitComment?: (body: string) => Promise
+ className?: string
+}
+
+/**
+ * The single diff renderer behind every Orca diff surface. Replaces the Monaco
+ * `DiffEditor` that used to mount once per visible file.
+ */
+export function PierreDiffSurface({
+ fileDiff,
+ sideBySide,
+ settings,
+ isEditable,
+ worktreeId,
+ filePath,
+ comments,
+ formatCommentPrompt,
+ onDeleteComment,
+ onUpdateComment,
+ onEditChange,
+ onPostRender,
+ onAddComment,
+ pendingComment,
+ addCommentPlaceholder,
+ addCommentLabel,
+ onCancelComment,
+ onSubmitComment,
+ className
+}: PierreDiffSurfaceProps): React.JSX.Element {
+ const editorFontZoomLevel = useAppStore((s) => s.editorFontZoomLevel)
+ const clearDeliveredDiffComments = useAppStore((s) => s.clearDeliveredDiffComments)
+ const activeGroupId = useAppStore((s) =>
+ worktreeId ? (s.activeGroupIdByWorktree[worktreeId] ?? worktreeId) : worktreeId
+ )
+ const { editEnabled, handleContainerKeyDown, handleEditorAttach } = usePierreDiffFind({
+ isEditable
+ })
+
+ const options = useMemo(
+ () => ({
+ ...buildPierreDiffOptions({ settings, sideBySide }),
+ enableGutterUtility: Boolean(onAddComment),
+ onGutterUtilityClick: onAddComment
+ ? (range: SelectedLineRange) =>
+ onAddComment({
+ lineNumber: Math.max(range.start, range.end),
+ startLine: range.start === range.end ? undefined : Math.min(range.start, range.end)
+ })
+ : undefined,
+ onPostRender: onPostRender
+ ? (node: HTMLElement, _instance: unknown, phase: PostRenderPhase) =>
+ onPostRender(node, phase)
+ : undefined
+ }),
+ [settings, sideBySide, onPostRender, onAddComment]
+ )
+ const style = useMemo(
+ () => buildPierreDiffStyle(settings, editorFontZoomLevel),
+ [settings, editorFontZoomLevel]
+ )
+ const lineAnnotations = useMemo(
+ () => buildPierreDiffCommentAnnotations(comments, pendingComment),
+ [comments, pendingComment]
+ )
+ const editorOptions = useMemo>(
+ () => ({
+ onAttach: handleEditorAttach,
+ onChange: (file) => onEditChange?.(file)
+ }),
+ [handleEditorAttach, onEditChange]
+ )
+ const renderAnnotation = useCallback(
+ (annotation: PierreDiffCommentAnnotation) =>
+ renderPierreDiffCommentAnnotation(annotation, {
+ worktreeId,
+ filePath,
+ activeGroupId,
+ formatCommentPrompt,
+ onDeleteComment,
+ onUpdateComment,
+ clearDeliveredDiffComments,
+ draftPlaceholder: addCommentPlaceholder,
+ draftSubmitLabel: addCommentLabel,
+ onCancelDraft: onCancelComment,
+ onSubmitDraft: onSubmitComment
+ }),
+ [
+ worktreeId,
+ filePath,
+ activeGroupId,
+ formatCommentPrompt,
+ onDeleteComment,
+ onUpdateComment,
+ clearDeliveredDiffComments,
+ addCommentPlaceholder,
+ addCommentLabel,
+ onCancelComment,
+ onSubmitComment
+ ]
+ )
+
+ return (
+ // Why: ⌘F must be caught before Pierre mounts an editor, so the listener lives on the host.
+
+
+ fileDiff={fileDiff}
+ options={options}
+ style={style}
+ edit={editEnabled}
+ editorOptions={editorOptions}
+ lineAnnotations={lineAnnotations}
+ renderAnnotation={renderAnnotation}
+ />
+
diff --git a/src/renderer/src/components/github-item-dialog/inspect-pull-request/pr-files-combined-diff-viewer.tsx b/src/renderer/src/components/github-item-dialog/inspect-pull-request/pr-files-combined-diff-viewer.tsx
index d6da1177779..1e798dbac35 100644
--- a/src/renderer/src/components/github-item-dialog/inspect-pull-request/pr-files-combined-diff-viewer.tsx
+++ b/src/renderer/src/components/github-item-dialog/inspect-pull-request/pr-files-combined-diff-viewer.tsx
@@ -1,6 +1,5 @@
import React, { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react'
import { useVirtualizer } from '@tanstack/react-virtual'
-import type { editor as monacoEditor } from 'monaco-editor'
import type { DecoratedDiffComment } from '@/components/diff-comments/decorated-diff-comment'
import { useCombinedDiffSectionIndexMap } from '../../editor/combined-diff/resolve-changes/use-combined-diff-section-index-map'
import { handleCombinedDiffFileTreeNavigation } from '../../editor/combined-diff/browse-files/combined-diff-file-tree-navigation'
@@ -28,6 +27,7 @@ import {
setAllPRFilesCombinedDiffSectionsCollapsed,
togglePRFilesCombinedDiffSection
} from './pr-files-combined-diff-load'
+import { PierreDiffProviders } from '@/components/editor/pierre-diff/PierreDiffProviders'
type PRFilesCombinedDiffSectionsProps = PRFilesCombinedDiffViewerProps & {
signature: string
@@ -92,9 +92,6 @@ function PRFilesCombinedDiffSections({
setFileTreeCollapsed
}: PRFilesCombinedDiffSectionsProps): React.JSX.Element {
const settings = useAppStore((s) => s.settings)
- const isDark =
- settings?.theme === 'dark' ||
- (settings?.theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches)
// Why: this subtree is keyed by the diff signature, so its file set is fixed for the
// mount. Freezing it in state keeps a stable identity without caching through a ref.
const [entries] = useState(() =>
@@ -161,7 +158,6 @@ function PRFilesCombinedDiffSections({
const loadedIndicesRef = useRef>(new Set())
const loadingIndicesRef = useRef>(new Set())
const sectionsRef = useRef(sections)
- const modifiedEditorsRef = useRef>(new Map())
const handleSectionSaveRef = useRef<(index: number) => Promise>(async () => {})
// Why: commit-phase write (a render React abandons would leak one), and it must be a layout
@@ -333,6 +329,7 @@ function PRFilesCombinedDiffSections({
)
return (
+
+
)
}
diff --git a/src/renderer/src/components/pull-request-page/files/combined-diff-viewer.tsx b/src/renderer/src/components/pull-request-page/files/combined-diff-viewer.tsx
index 68592865d47..6ac8f3aac39 100644
--- a/src/renderer/src/components/pull-request-page/files/combined-diff-viewer.tsx
+++ b/src/renderer/src/components/pull-request-page/files/combined-diff-viewer.tsx
@@ -1,6 +1,5 @@
import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
import { useVirtualizer } from '@tanstack/react-virtual'
-import type { editor as monacoEditor } from 'monaco-editor'
import { useAppStore } from '@/store'
import { DiffSectionItem } from '@/components/editor/DiffSectionItem'
import { CombinedDiffFileTree } from '../../editor/combined-diff/browse-files/combined-diff-file-tree'
@@ -28,6 +27,7 @@ import { usePRFilesDiffViewPersistence } from './view-restore'
import { buildInlineReviewComments } from './inline-comments'
import { usePRFileSectionHeights } from './section-heights'
import { usePRFileActiveSection } from './active-section'
+import { PierreDiffProviders } from '@/components/editor/pierre-diff/PierreDiffProviders'
export function PRFilesCombinedDiffViewer({
files,
@@ -45,9 +45,6 @@ export function PRFilesCombinedDiffViewer({
onViewedChange
}: PRFilesCombinedDiffViewerProps): React.JSX.Element {
const settings = useAppStore((s) => s.settings)
- const isDark =
- settings?.theme === 'dark' ||
- (settings?.theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches)
const diffEntrySignature = useMemo(
() =>
JSON.stringify(
@@ -116,7 +113,6 @@ export function PRFilesCombinedDiffViewer({
const loadingIndicesRef = useRef>(new Set())
const sectionsRef = useRef([])
const generationRef = useRef(0)
- const modifiedEditorsRef = useRef>(new Map())
const handleSectionSaveRef = useRef<(index: number) => Promise>(async () => {})
useLayoutEffect(() => {
// Why: keep the loader/navigation callbacks reading the latest sections without a render-phase ref write.
@@ -308,6 +304,7 @@ export function PRFilesCombinedDiffViewer({
)
return (
+
@@ -377,5 +372,6 @@ export function PRFilesCombinedDiffViewer({