@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorViewModel.js

@@ -3,16 +3,19 @@ import { RunOnceScheduler } from '../../../../base/common/async.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
 import { IDiffProviderFactoryService } from './diffProviderFactoryService.js';
-import { readHotReloadableExport } from './utils.js';
-import { LineRange } from '../../../common/core/lineRange.js';
+import { readHotReloadableExport, filterWithPrevious } from './utils.js';
+import { LineRange, LineRangeSet } from '../../../common/core/lineRange.js';
 import { DefaultLinesDiffComputer } from '../../../common/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.js';
-import { DetailedLineRangeMapping, RangeMapping } from '../../../common/diff/rangeMapping.js';
+import { DetailedLineRangeMapping, LineRangeMapping, RangeMapping } from '../../../common/diff/rangeMapping.js';
 import { TextEditInfo } from '../../../common/model/bracketPairsTextModelPart/bracketPairsTree/beforeEditPositionMapper.js';
 import { combineTextEditInfos } from '../../../common/model/bracketPairsTextModelPart/bracketPairsTree/combineTextEditInfos.js';
 import { optimizeSequenceDiffs } from '../../../common/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.js';
+import { isDefined } from '../../../../base/common/types.js';
+import { groupAdjacentBy } from '../../../../base/common/arrays.js';
+import { softAssert } from '../../../../base/common/assert.js';
 import { observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
 import { derived } from '../../../../base/common/observableInternal/derived.js';
-import { autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
+import { autorun, autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
 import { waitForState, observableSignalFromEvent, observableSignal } from '../../../../base/common/observableInternal/utils.js';
 let DiffEditorViewModel = class DiffEditorViewModel extends Disposable {
     setActiveMovedText(movedText) {
@@ -30,14 +33,14 @@ let DiffEditorViewModel = class DiffEditorViewModel extends Disposable {
         this.isDiffUpToDate = this._isDiffUpToDate;
         this._diff = observableValue(this, undefined);
         this.diff = this._diff;
-        this._unchangedRegions = observableValue(this, { regions: [], originalDecorationIds: [], modifiedDecorationIds: [] });
+        this._unchangedRegions = observableValue(this, undefined);
         this.unchangedRegions = derived(this, r => {
             if (this._options.hideUnchangedRegions.read(r)) {
-                return this._unchangedRegions.read(r).regions;
+                return this._unchangedRegions.read(r)?.regions ?? [];
             }
             else {
                 transaction(tx => {
-                    for (const r of this._unchangedRegions.get().regions) {
+                    for (const r of this._unchangedRegions.get()?.regions || []) {
                         r.collapseAll(tx);
                     }
                 });
@@ -62,32 +65,109 @@ let DiffEditorViewModel = class DiffEditorViewModel extends Disposable {
         this._register(toDisposable(() => this._cancellationTokenSource.cancel()));
         const contentChangedSignal = observableSignal('contentChangedSignal');
         const debouncer = this._register(( new RunOnceScheduler(() => contentChangedSignal.trigger(undefined), 200)));
-        const updateUnchangedRegions = (result, tx, reader) => {
-            const newUnchangedRegions = UnchangedRegion.fromDiffs(result.changes, model.original.getLineCount(), model.modified.getLineCount(), this._options.hideUnchangedRegionsMinimumLineCount.read(reader), this._options.hideUnchangedRegionsContextLineCount.read(reader));
-            const lastUnchangedRegions = this._unchangedRegions.get();
+        this._register(autorun(reader => {
+            const lastUnchangedRegions = this._unchangedRegions.read(reader);
+            if (!lastUnchangedRegions || ( lastUnchangedRegions.regions.some(r => r.isDragged.read(reader)))) {
+                return;
+            }
             const lastUnchangedRegionsOrigRanges = ( ( lastUnchangedRegions.originalDecorationIds
                 .map(id => model.original.getDecorationRange(id)))
-                .map(r => r ? LineRange.fromRange(r) : undefined));
+                .map(r => r ? LineRange.fromRangeInclusive(r) : undefined));
             const lastUnchangedRegionsModRanges = ( ( lastUnchangedRegions.modifiedDecorationIds
                 .map(id => model.modified.getDecorationRange(id)))
-                .map(r => r ? LineRange.fromRange(r) : undefined));
-            const originalDecorationIds = model.original.deltaDecorations(lastUnchangedRegions.originalDecorationIds, ( newUnchangedRegions.map(
+                .map(r => r ? LineRange.fromRangeInclusive(r) : undefined));
+            const updatedLastUnchangedRegions = ( lastUnchangedRegions.regions.map(
+                (r, idx) => (!lastUnchangedRegionsOrigRanges[idx] || !lastUnchangedRegionsModRanges[idx]) ? undefined :
+                    ( new UnchangedRegion(
+                        lastUnchangedRegionsOrigRanges[idx].startLineNumber,
+                        lastUnchangedRegionsModRanges[idx].startLineNumber,
+                        lastUnchangedRegionsOrigRanges[idx].length,
+                        r.visibleLineCountTop.read(reader),
+                        r.visibleLineCountBottom.read(reader)
+                    ))
+            )).filter(isDefined);
+            const newRanges = [];
+            let didChange = false;
+            for (const touching of groupAdjacentBy(updatedLastUnchangedRegions, (a, b) => a.getHiddenModifiedRange(reader).endLineNumberExclusive === b.getHiddenModifiedRange(reader).startLineNumber)) {
+                if (touching.length > 1) {
+                    didChange = true;
+                    const sumLineCount = touching.reduce((sum, r) => sum + r.lineCount, 0);
+                    const r = ( new UnchangedRegion(
+                        touching[0].originalLineNumber,
+                        touching[0].modifiedLineNumber,
+                        sumLineCount,
+                        touching[0].visibleLineCountTop.get(),
+                        touching[touching.length - 1].visibleLineCountBottom.get()
+                    ));
+                    newRanges.push(r);
+                }
+                else {
+                    newRanges.push(touching[0]);
+                }
+            }
+            if (didChange) {
+                const originalDecorationIds = model.original.deltaDecorations(lastUnchangedRegions.originalDecorationIds, ( newRanges.map(
+                    r => ({ range: r.originalUnchangedRange.toInclusiveRange(), options: { description: 'unchanged' } })
+                )));
+                const modifiedDecorationIds = model.modified.deltaDecorations(lastUnchangedRegions.modifiedDecorationIds, ( newRanges.map(
+                    r => ({ range: r.modifiedUnchangedRange.toInclusiveRange(), options: { description: 'unchanged' } })
+                )));
+                transaction(tx => {
+                    this._unchangedRegions.set({
+                        regions: newRanges,
+                        originalDecorationIds,
+                        modifiedDecorationIds
+                    }, tx);
+                });
+            }
+        }));
+        const updateUnchangedRegions = (result, tx, reader) => {
+            const newUnchangedRegions = UnchangedRegion.fromDiffs(result.changes, model.original.getLineCount(), model.modified.getLineCount(), this._options.hideUnchangedRegionsMinimumLineCount.read(reader), this._options.hideUnchangedRegionsContextLineCount.read(reader));
+            let visibleRegions = undefined;
+            const lastUnchangedRegions = this._unchangedRegions.get();
+            if (lastUnchangedRegions) {
+                const lastUnchangedRegionsOrigRanges = ( ( lastUnchangedRegions.originalDecorationIds
+                    .map(id => model.original.getDecorationRange(id)))
+                    .map(r => r ? LineRange.fromRangeInclusive(r) : undefined));
+                const lastUnchangedRegionsModRanges = ( ( lastUnchangedRegions.modifiedDecorationIds
+                    .map(id => model.modified.getDecorationRange(id)))
+                    .map(r => r ? LineRange.fromRangeInclusive(r) : undefined));
+                const updatedLastUnchangedRegions = filterWithPrevious(( lastUnchangedRegions.regions
+                    .map((r, idx) => {
+                    if (!lastUnchangedRegionsOrigRanges[idx] || !lastUnchangedRegionsModRanges[idx]) {
+                        return undefined;
+                    }
+                    const length = lastUnchangedRegionsOrigRanges[idx].length;
+                    return ( new UnchangedRegion(
+                        lastUnchangedRegionsOrigRanges[idx].startLineNumber,
+                        lastUnchangedRegionsModRanges[idx].startLineNumber,
+                        length,
+                        Math.min(r.visibleLineCountTop.get(), length),
+                        Math.min(r.visibleLineCountBottom.get(), length - r.visibleLineCountTop.get())
+                    ));
+                })).filter(isDefined), (cur, prev) => !prev || (cur.modifiedLineNumber >= prev.modifiedLineNumber + prev.lineCount && cur.originalLineNumber >= prev.originalLineNumber + prev.lineCount));
+                let hiddenRegions = ( updatedLastUnchangedRegions.map(r => ( new LineRangeMapping(r.getHiddenOriginalRange(reader), r.getHiddenModifiedRange(reader)))));
+                hiddenRegions = LineRangeMapping.clip(hiddenRegions, LineRange.ofLength(1, model.original.getLineCount()), LineRange.ofLength(1, model.modified.getLineCount()));
+                visibleRegions = LineRangeMapping.inverse(hiddenRegions, model.original.getLineCount(), model.modified.getLineCount());
+            }
+            const newUnchangedRegions2 = [];
+            if (visibleRegions) {
+                for (const r of newUnchangedRegions) {
+                    const intersecting = visibleRegions.filter(f => f.original.intersectsStrict(r.originalUnchangedRange) && f.modified.intersectsStrict(r.modifiedUnchangedRange));
+                    newUnchangedRegions2.push(...r.setVisibleRanges(intersecting, tx));
+                }
+            }
+            else {
+                newUnchangedRegions2.push(...newUnchangedRegions);
+            }
+            const originalDecorationIds = model.original.deltaDecorations(lastUnchangedRegions?.originalDecorationIds || [], ( newUnchangedRegions2.map(
                 r => ({ range: r.originalUnchangedRange.toInclusiveRange(), options: { description: 'unchanged' } })
             )));
-            const modifiedDecorationIds = model.modified.deltaDecorations(lastUnchangedRegions.modifiedDecorationIds, ( newUnchangedRegions.map(
+            const modifiedDecorationIds = model.modified.deltaDecorations(lastUnchangedRegions?.modifiedDecorationIds || [], ( newUnchangedRegions2.map(
                 r => ({ range: r.modifiedUnchangedRange.toInclusiveRange(), options: { description: 'unchanged' } })
             )));
-            for (const r of newUnchangedRegions) {
-                for (let i = 0; i < lastUnchangedRegions.regions.length; i++) {
-                    if (lastUnchangedRegionsOrigRanges[i] && r.originalUnchangedRange.intersectsStrict(lastUnchangedRegionsOrigRanges[i])
-                        && lastUnchangedRegionsModRanges[i] && r.modifiedUnchangedRange.intersectsStrict(lastUnchangedRegionsModRanges[i])) {
-                        r.setHiddenModifiedRange(lastUnchangedRegions.regions[i].getHiddenModifiedRange(undefined), tx);
-                        break;
-                    }
-                }
-            }
             this._unchangedRegions.set({
-                regions: newUnchangedRegions,
+                regions: newUnchangedRegions2,
                 originalDecorationIds,
                 modifiedDecorationIds
             }, tx);
@@ -150,26 +230,26 @@ let DiffEditorViewModel = class DiffEditorViewModel extends Disposable {
             });
         }));
     }
-    ensureModifiedLineIsVisible(lineNumber, tx) {
+    ensureModifiedLineIsVisible(lineNumber, preference, tx) {
         if (this.diff.get()?.mappings.length === 0) {
             return;
         }
-        const unchangedRegions = this._unchangedRegions.get().regions;
+        const unchangedRegions = this._unchangedRegions.get()?.regions || [];
         for (const r of unchangedRegions) {
             if (r.getHiddenModifiedRange(undefined).contains(lineNumber)) {
-                r.showModifiedLine(lineNumber, tx);
+                r.showModifiedLine(lineNumber, preference, tx);
                 return;
             }
         }
     }
-    ensureOriginalLineIsVisible(lineNumber, tx) {
+    ensureOriginalLineIsVisible(lineNumber, preference, tx) {
         if (this.diff.get()?.mappings.length === 0) {
             return;
         }
-        const unchangedRegions = this._unchangedRegions.get().regions;
+        const unchangedRegions = this._unchangedRegions.get()?.regions || [];
         for (const r of unchangedRegions) {
             if (r.getHiddenOriginalRange(undefined).contains(lineNumber)) {
-                r.showOriginalLine(lineNumber, tx);
+                r.showOriginalLine(lineNumber, preference, tx);
                 return;
             }
         }
@@ -180,12 +260,15 @@ let DiffEditorViewModel = class DiffEditorViewModel extends Disposable {
     serializeState() {
         const regions = this._unchangedRegions.get();
         return {
-            collapsedRegions: ( regions.regions.map(r => ({ range: r.getHiddenModifiedRange(undefined).serialize() })))
+            collapsedRegions: regions?.regions.map(r => ({ range: r.getHiddenModifiedRange(undefined).serialize() }))
         };
     }
     restoreSerializedState(state) {
-        const ranges = ( state.collapsedRegions.map(r => LineRange.deserialize(r.range)));
+        const ranges = state.collapsedRegions?.map(r => LineRange.deserialize(r.range));
         const regions = this._unchangedRegions.get();
+        if (!regions || !ranges) {
+            return;
+        }
         transaction(tx => {
             for (const r of regions.regions) {
                 for (const range of ranges) {
@@ -284,8 +367,37 @@ class UnchangedRegion {
         this.visibleLineCountBottom = this._visibleLineCountBottom;
         this._shouldHideControls = derived(this, reader =>  this.visibleLineCountTop.read(reader) + this.visibleLineCountBottom.read(reader) === this.lineCount && !this.isDragged.read(reader));
         this.isDragged = observableValue(this, undefined);
-        this._visibleLineCountTop.set(visibleLineCountTop, undefined);
-        this._visibleLineCountBottom.set(visibleLineCountBottom, undefined);
+        const visibleLineCountTop2 = Math.max(Math.min(visibleLineCountTop, this.lineCount), 0);
+        const visibleLineCountBottom2 = Math.max(Math.min(visibleLineCountBottom, this.lineCount - visibleLineCountTop), 0);
+        softAssert(visibleLineCountTop === visibleLineCountTop2);
+        softAssert(visibleLineCountBottom === visibleLineCountBottom2);
+        this._visibleLineCountTop.set(visibleLineCountTop2, undefined);
+        this._visibleLineCountBottom.set(visibleLineCountBottom2, undefined);
+    }
+    setVisibleRanges(visibleRanges, tx) {
+        const result = [];
+        const hiddenModified = ( new LineRangeSet(( visibleRanges.map(r => r.modified)))).subtractFrom(this.modifiedUnchangedRange);
+        let originalStartLineNumber = this.originalLineNumber;
+        let modifiedStartLineNumber = this.modifiedLineNumber;
+        const modifiedEndLineNumberEx = this.modifiedLineNumber + this.lineCount;
+        if (hiddenModified.ranges.length === 0) {
+            this.showAll(tx);
+            result.push(this);
+        }
+        else {
+            let i = 0;
+            for (const r of hiddenModified.ranges) {
+                const isLast = i === hiddenModified.ranges.length - 1;
+                i++;
+                const length = (isLast ? modifiedEndLineNumberEx : r.endLineNumberExclusive) - modifiedStartLineNumber;
+                const newR = ( new UnchangedRegion(originalStartLineNumber, modifiedStartLineNumber, length, 0, 0));
+                newR.setHiddenModifiedRange(r, tx);
+                result.push(newR);
+                originalStartLineNumber = newR.originalUnchangedRange.endLineNumberExclusive;
+                modifiedStartLineNumber = newR.modifiedUnchangedRange.endLineNumberExclusive;
+            }
+        }
+        return result;
     }
     shouldHideControls(reader) {
         return this._shouldHideControls.read(reader);
@@ -318,20 +430,20 @@ class UnchangedRegion {
     showAll(tx) {
         this._visibleLineCountBottom.set(this.lineCount - this._visibleLineCountTop.get(), tx);
     }
-    showModifiedLine(lineNumber, tx) {
+    showModifiedLine(lineNumber, preference, tx) {
         const top = lineNumber + 1 - (this.modifiedLineNumber + this._visibleLineCountTop.get());
         const bottom = (this.modifiedLineNumber - this._visibleLineCountBottom.get() + this.lineCount) - lineNumber;
-        if (top < bottom) {
+        if (preference === 0  && top < bottom || preference === 1 ) {
             this._visibleLineCountTop.set(this._visibleLineCountTop.get() + top, tx);
         }
         else {
             this._visibleLineCountBottom.set(this._visibleLineCountBottom.get() + bottom, tx);
         }
     }
-    showOriginalLine(lineNumber, tx) {
+    showOriginalLine(lineNumber, preference, tx) {
         const top = lineNumber - this.originalLineNumber;
         const bottom = (this.originalLineNumber + this.lineCount) - lineNumber;
-        if (top < bottom) {
+        if (preference === 0  && top < bottom || preference === 1 ) {
             this._visibleLineCountTop.set(Math.min(this._visibleLineCountTop.get() + bottom - top, this.getMaxVisibleLineCountTop()), tx);
         }
         else {

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorWidget.js

@@ -10,13 +10,13 @@ import { EditorExtensionsRegistry } from '../../editorExtensions.js';
 import { ICodeEditorService } from '../../services/codeEditorService.js';
 import { StableEditorScrollState } from '../../stableEditorScroll.js';
 import { CodeEditorWidget } from '../codeEditorWidget.js';
-import { AccessibleDiffViewer } from './accessibleDiffViewer.js';
-import { DiffEditorDecorations } from './diffEditorDecorations.js';
-import { DiffEditorSash } from './diffEditorSash.js';
-import { HideUnchangedRegionsFeature } from './hideUnchangedRegionsFeature.js';
-import { ViewZoneManager } from './lineAlignment.js';
-import { MovedBlocksLinesPart } from './movedBlocksLines.js';
-import { OverviewRulerPart } from './overviewRulerPart.js';
+import { AccessibleDiffViewer } from './components/accessibleDiffViewer.js';
+import { DiffEditorDecorations } from './components/diffEditorDecorations.js';
+import { DiffEditorSash } from './components/diffEditorSash.js';
+import { HideUnchangedRegionsFeature } from './features/hideUnchangedRegionsFeature.js';
+import { DiffEditorViewZones } from './components/diffEditorViewZones/diffEditorViewZones.js';
+import { MovedBlocksLinesFeature } from './features/movedBlocksLinesFeature.js';
+import { OverviewRulerFeature } from './features/overviewRulerFeature.js';
 import { ObservableElementSizeObserver, bindContextKey, applyViewZones, applyStyle, translatePosition, readHotReloadableExport } from './utils.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
@@ -27,16 +27,16 @@ import { IContextKeyService } from '../../../../platform/contextkey/common/conte
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
 import { IEditorProgressService } from '../../../../platform/progress/common/progress.js';
-import './colors.js';
 import { DelegatingEditor } from './delegatingEditorImpl.js';
-import { DiffEditorEditors } from './diffEditorEditors.js';
+import { DiffEditorEditors } from './components/diffEditorEditors.js';
 import { DiffEditorOptions } from './diffEditorOptions.js';
 import { DiffEditorViewModel } from './diffEditorViewModel.js';
+import { RevertButtonsFeature } from './features/revertButtonsFeature.js';
 import { observableValue, subtransaction, transaction } from '../../../../base/common/observableInternal/base.js';
 import { autorun, autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
 import { recomputeInitiallyAndOnChange, observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
 let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
-    static { this.ENTIRE_DIFF_OVERVIEW_WIDTH = OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH; }
+    static { this.ENTIRE_DIFF_OVERVIEW_WIDTH = OverviewRulerFeature.ENTIRE_DIFF_OVERVIEW_WIDTH; }
     get onDidContentSizeChange() { return this._editors.onDidContentSizeChange; }
     get collapseUnchangedRegions() { return this._options.hideUnchangedRegions.get(); }
     constructor(_domElement, options, codeEditorWidgetOptions, _parentContextKeyService, _parentInstantiationService, codeEditorService, _audioCueService, _editorProgressService) {
@@ -102,7 +102,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._editors = this._register(this._instantiationService.createInstance(DiffEditorEditors, this.elements.original, this.elements.modified, this._options, codeEditorWidgetOptions, (i, c, o, o2) => this._createInnerEditor(i, c, o, o2)));
         this._overviewRulerPart = derivedDisposable(this, reader => !this._options.renderOverviewRuler.read(reader)
             ? undefined
-            : this._instantiationService.createInstance(readHotReloadableExport(OverviewRulerPart, reader), this._editors, this.elements.root, this._diffModel, this._rootSizeObserver.width, this._rootSizeObserver.height, ( this._layoutInfo.map(i => i.modifiedEditor)))).recomputeInitiallyAndOnChange(this._store);
+            : this._instantiationService.createInstance(readHotReloadableExport(OverviewRulerFeature, reader), this._editors, this.elements.root, this._diffModel, this._rootSizeObserver.width, this._rootSizeObserver.height, ( this._layoutInfo.map(i => i.modifiedEditor)))).recomputeInitiallyAndOnChange(this._store);
         this._sash = derivedDisposable(this, reader => {
             const showSash = this._options.renderSideBySide.read(reader);
             this.elements.root.classList.toggle('side-by-side', showSash);
@@ -116,7 +116,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         const origViewZoneIdsToIgnore = ( new Set());
         const modViewZoneIdsToIgnore = ( new Set());
         let isUpdatingViewZones = false;
-        const viewZoneManager = derivedDisposable(this, reader =>  this._instantiationService.createInstance(readHotReloadableExport(ViewZoneManager, reader), getWindow(this._domElement), this._editors, this._diffModel, this._options, this, () => isUpdatingViewZones || unchangedRangesFeature.get().isUpdatingHiddenAreas, origViewZoneIdsToIgnore, modViewZoneIdsToIgnore)).recomputeInitiallyAndOnChange(this._store);
+        const viewZoneManager = derivedDisposable(this, reader =>  this._instantiationService.createInstance(readHotReloadableExport(DiffEditorViewZones, reader), getWindow(this._domElement), this._editors, this._diffModel, this._options, this, () => isUpdatingViewZones || unchangedRangesFeature.get().isUpdatingHiddenAreas, origViewZoneIdsToIgnore, modViewZoneIdsToIgnore)).recomputeInitiallyAndOnChange(this._store);
         const originalViewZones = derived(this, (reader) => {
             const orig = viewZoneManager.read(reader).viewZones.read(reader).orig;
             const orig2 = unchangedRangesFeature.read(reader).viewZones.read(reader).origViewZones;
@@ -148,7 +148,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._createDiffEditorContributions();
         codeEditorService.addDiffEditor(this);
         this._register(recomputeInitiallyAndOnChange(this._layoutInfo));
-        derivedDisposable(this, reader =>  new (readHotReloadableExport(MovedBlocksLinesPart, reader))(this.elements.root, this._diffModel, ( this._layoutInfo.map(i => i.originalEditor)), ( this._layoutInfo.map(i => i.modifiedEditor)), this._editors)).recomputeInitiallyAndOnChange(this._store, value => {
+        derivedDisposable(this, reader =>  new (readHotReloadableExport(MovedBlocksLinesFeature, reader))(this.elements.root, this._diffModel, ( this._layoutInfo.map(i => i.originalEditor)), ( this._layoutInfo.map(i => i.modifiedEditor)), this._editors)).recomputeInitiallyAndOnChange(this._store, value => {
             this._movedBlocksLinesPart.set(value, undefined);
         });
         this._register(applyStyle(this.elements.overlay, {
@@ -189,6 +189,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
                 this._diffModel.get()?.dispose();
             }
         }));
+        this._register(( new RevertButtonsFeature(this._editors, this._diffModel, this._options, this)));
     }
     getViewWidth() {
         return this._rootSizeObserver.width.get();
@@ -309,14 +310,14 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
             this.revertRangeMappings(diff.innerChanges);
             return;
         }
-        const model = this._diffModel.get()?.model;
-        if (!model) {
+        const model = this._diffModel.get();
+        if (!model || !model.isDiffUpToDate.get()) {
             return;
         }
         this._editors.modified.executeEdits('diffEditor', [
             {
                 range: diff.modified.toExclusiveRange(),
-                text: model.original.getValueInRange(diff.original.toExclusiveRange())
+                text: model.model.original.getValueInRange(diff.original.toExclusiveRange())
             }
         ]);
     }

package/vscode/src/vs/editor/browser/widget/diffEditor/diffProviderFactoryService.js

@@ -1,9 +1,15 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { WorkerBasedDocumentDiffProvider } from './workerBasedDocumentDiffProvider.js';
 import { registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
 import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { StopWatch } from '../../../../base/common/stopwatch.js';
+import { LineRange } from '../../../common/core/lineRange.js';
+import { DetailedLineRangeMapping, RangeMapping } from '../../../common/diff/rangeMapping.js';
+import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+var WorkerBasedDocumentDiffProvider_1;
 const IDiffProviderFactoryService = ( createDecorator('diffProviderFactoryService'));
-let DiffProviderFactoryService = class DiffProviderFactoryService {
+let WorkerBasedDiffProviderFactoryService = class WorkerBasedDiffProviderFactoryService {
     constructor(instantiationService) {
         this.instantiationService = instantiationService;
     }
@@ -11,8 +17,100 @@ let DiffProviderFactoryService = class DiffProviderFactoryService {
         return this.instantiationService.createInstance(WorkerBasedDocumentDiffProvider, options);
     }
 };
-DiffProviderFactoryService = ( __decorate([
+WorkerBasedDiffProviderFactoryService = ( __decorate([
     ( __param(0, IInstantiationService))
-], DiffProviderFactoryService));
-registerSingleton(IDiffProviderFactoryService, DiffProviderFactoryService, 1 );
-export { DiffProviderFactoryService, IDiffProviderFactoryService };
+], WorkerBasedDiffProviderFactoryService));
+registerSingleton(IDiffProviderFactoryService, WorkerBasedDiffProviderFactoryService, 1 );
+let WorkerBasedDocumentDiffProvider = class WorkerBasedDocumentDiffProvider {
+    static { WorkerBasedDocumentDiffProvider_1 = this; }
+    static { this.diffCache = ( new Map()); }
+    constructor(options, editorWorkerService, telemetryService) {
+        this.editorWorkerService = editorWorkerService;
+        this.telemetryService = telemetryService;
+        this.onDidChangeEventEmitter = ( new Emitter());
+        this.onDidChange = this.onDidChangeEventEmitter.event;
+        this.diffAlgorithm = 'advanced';
+        this.diffAlgorithmOnDidChangeSubscription = undefined;
+        this.setOptions(options);
+    }
+    dispose() {
+        this.diffAlgorithmOnDidChangeSubscription?.dispose();
+    }
+    async computeDiff(original, modified, options, cancellationToken) {
+        if (typeof this.diffAlgorithm !== 'string') {
+            return this.diffAlgorithm.computeDiff(original, modified, options, cancellationToken);
+        }
+        if (original.getLineCount() === 1 && original.getLineMaxColumn(1) === 1) {
+            if (modified.getLineCount() === 1 && modified.getLineMaxColumn(1) === 1) {
+                return {
+                    changes: [],
+                    identical: true,
+                    quitEarly: false,
+                    moves: [],
+                };
+            }
+            return {
+                changes: [
+                    ( new DetailedLineRangeMapping(( new LineRange(1, 2)), ( new LineRange(1, modified.getLineCount() + 1)), [
+                        ( new RangeMapping(original.getFullModelRange(), modified.getFullModelRange()))
+                    ]))
+                ],
+                identical: false,
+                quitEarly: false,
+                moves: [],
+            };
+        }
+        const uriKey = JSON.stringify([( original.uri.toString()), ( modified.uri.toString())]);
+        const context = JSON.stringify([original.id, modified.id, original.getAlternativeVersionId(), modified.getAlternativeVersionId(), JSON.stringify(options)]);
+        const c = WorkerBasedDocumentDiffProvider_1.diffCache.get(uriKey);
+        if (c && c.context === context) {
+            return c.result;
+        }
+        const sw = StopWatch.create();
+        const result = await this.editorWorkerService.computeDiff(original.uri, modified.uri, options, this.diffAlgorithm);
+        const timeMs = sw.elapsed();
+        this.telemetryService.publicLog2('diffEditor.computeDiff', {
+            timeMs,
+            timedOut: result?.quitEarly ?? true,
+            detectedMoves: options.computeMoves ? (result?.moves.length ?? 0) : -1,
+        });
+        if (cancellationToken.isCancellationRequested) {
+            return {
+                changes: [],
+                identical: false,
+                quitEarly: true,
+                moves: [],
+            };
+        }
+        if (!result) {
+            throw new Error('no diff result available');
+        }
+        if (WorkerBasedDocumentDiffProvider_1.diffCache.size > 10) {
+            WorkerBasedDocumentDiffProvider_1.diffCache.delete(( WorkerBasedDocumentDiffProvider_1.diffCache.keys()).next().value);
+        }
+        WorkerBasedDocumentDiffProvider_1.diffCache.set(uriKey, { result, context });
+        return result;
+    }
+    setOptions(newOptions) {
+        let didChange = false;
+        if (newOptions.diffAlgorithm) {
+            if (this.diffAlgorithm !== newOptions.diffAlgorithm) {
+                this.diffAlgorithmOnDidChangeSubscription?.dispose();
+                this.diffAlgorithmOnDidChangeSubscription = undefined;
+                this.diffAlgorithm = newOptions.diffAlgorithm;
+                if (typeof newOptions.diffAlgorithm !== 'string') {
+                    this.diffAlgorithmOnDidChangeSubscription = newOptions.diffAlgorithm.onDidChange(() => this.onDidChangeEventEmitter.fire());
+                }
+                didChange = true;
+            }
+        }
+        if (didChange) {
+            this.onDidChangeEventEmitter.fire();
+        }
+    }
+};
+WorkerBasedDocumentDiffProvider = WorkerBasedDocumentDiffProvider_1 = ( __decorate([
+    ( __param(1, IEditorWorkerService)),
+    ( __param(2, ITelemetryService))
+], WorkerBasedDocumentDiffProvider));
+export { IDiffProviderFactoryService, WorkerBasedDiffProviderFactoryService, WorkerBasedDocumentDiffProvider };