@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLineOptions.js

@@ -20,6 +20,7 @@ class ViewLineOptions {
         this.fontLigatures = options.get(EditorOption.fontLigatures);
         this.verticalScrollbarSize = options.get(EditorOption.scrollbar).verticalScrollbarSize;
         this.useGpu = options.get(EditorOption.experimentalGpuAcceleration) === 'on';
+        this.useTwoCellFullwidthCharacters = options.get(EditorOption.effectiveFullwidthCharacterWidth) === 'twoCells';
     }
     equals(other) {
         return (this.themeType === other.themeType
@@ -35,7 +36,8 @@ class ViewLineOptions {
             && this.stopRenderingLineAfter === other.stopRenderingLineAfter
             && this.fontLigatures === other.fontLigatures
             && this.verticalScrollbarSize === other.verticalScrollbarSize
-            && this.useGpu === other.useGpu);
+            && this.useGpu === other.useGpu
+            && this.useTwoCellFullwidthCharacters === other.useTwoCellFullwidthCharacters);
     }
 }
 

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLines.css

@@ -19,6 +19,18 @@
 	background: rgb(150, 0, 0) !important;
 }
 
+/*
+ * A full-width character centered in exactly two character cells. The cell width is editor
+ * specific and stays inline. Deliberately not scoped to `.monaco-editor`, so that the lines
+ * `DOMLineBreaksComputer` measures in a container attached to the document body are styled
+ * the same way as the rendered ones.
+ */
+.mtkfullwidth {
+	display: inline-block;
+	box-sizing: border-box;
+	text-align: center;
+}
+
 .mtkoverflow {
 	background-color: var(--vscode-button-background, var(--vscode-editor-background));
 	color: var(--vscode-button-foreground, var(--vscode-editor-foreground));

package/vscode/src/vs/editor/browser/widget/diffEditor/components/accessibleDiffViewer.d.ts

@@ -34,7 +34,7 @@ export declare class AccessibleDiffViewer extends Disposable {
     private readonly _diffs;
     private readonly _models;
     private readonly _instantiationService;
-    static _ttPolicy: Pick<TrustedTypePolicy, "name" | "createHTML"> | undefined;
+    static _ttPolicy: Pick<TrustedTypePolicy, "createHTML" | "name"> | undefined;
     constructor(_parentNode: HTMLElement, _visible: IObservable<boolean>, _setVisible: (visible: boolean, tx: ITransaction | undefined) => void, _canClose: IObservable<boolean>, _width: IObservable<number>, _height: IObservable<number>, _diffs: IObservable<DetailedLineRangeMapping[] | undefined>, _models: IAccessibleDiffViewerModel, _instantiationService: IInstantiationService);
     private readonly _state;
     next(): void;

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorEditors.d.ts

@@ -32,6 +32,7 @@ export declare class DiffEditorEditors extends Disposable {
     readonly isOriginalFocused: import("../../../../../base/common/observable.js").IObservable<boolean>;
     readonly isModifiedFocused: import("../../../../../base/common/observable.js").IObservable<boolean>;
     readonly isFocused: import("../../../../../base/common/observable.js").IObservableWithChange<boolean, void>;
+    getContentHeight(): number;
     constructor(originalEditorElement: HTMLElement, modifiedEditorElement: HTMLElement, _options: DiffEditorOptions, _argCodeEditorWidgetOptions: IDiffCodeEditorWidgetOptions, _createInnerEditor: (instantiationService: IInstantiationService, container: HTMLElement, options: Readonly<IEditorOptions>, editorWidgetOptions: ICodeEditorWidgetOptions) => CodeEditorWidget, _contextKeyService: IContextKeyService, _instantiationService: IInstantiationService, _keybindingService: IKeybindingService);
     private _createLeftHandSideEditor;
     private _createRightHandSideEditor;

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorEditors.js

@@ -19,6 +19,9 @@ let DiffEditorEditors = class DiffEditorEditors extends Disposable {
     get onDidContentSizeChange() {
         return this._onDidContentSizeChange.event;
     }
+    getContentHeight() {
+        return Math.max(this.modified.getContentHeight(), this.original.getContentHeight());
+    }
     constructor(
         originalEditorElement,
         modifiedEditorElement,
@@ -128,9 +131,8 @@ let DiffEditorEditors = class DiffEditorEditors extends Disposable {
         const editor = this._createInnerEditor(instantiationService, container, options, editorWidgetOptions);
         this._register(editor.onDidContentSizeChange(e => {
             const width = this.original.getContentWidth() + this.modified.getContentWidth() + OverviewRulerFeature.ENTIRE_DIFF_OVERVIEW_WIDTH;
-            const height = Math.max(this.modified.getContentHeight(), this.original.getContentHeight());
             this._onDidContentSizeChange.fire({
-                contentHeight: height,
+                contentHeight: this.getContentHeight(),
                 contentWidth: width,
                 contentHeightChanged: e.contentHeightChanged,
                 contentWidthChanged: e.contentWidthChanged

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines.d.ts

@@ -27,9 +27,10 @@ export declare class RenderOptions {
     readonly renderControlCharacters: boolean;
     readonly fontLigatures: FindComputedEditorOptionValueById<EditorOption.fontLigatures>;
     readonly verticalScrollbarSize: number;
+    readonly useTwoCellFullwidthCharacters: boolean;
     readonly setWidth: boolean;
     static fromEditor(editor: ICodeEditor): RenderOptions;
-    constructor(tabSize: number, fontInfo: FontInfo, disableMonospaceOptimizations: boolean, typicalHalfwidthCharacterWidth: number, scrollBeyondLastColumn: number, lineHeight: number, lineDecorationsWidth: number, stopRenderingLineAfter: number, renderWhitespace: FindComputedEditorOptionValueById<EditorOption.renderWhitespace>, renderControlCharacters: boolean, fontLigatures: FindComputedEditorOptionValueById<EditorOption.fontLigatures>, verticalScrollbarSize: number, setWidth?: boolean);
+    constructor(tabSize: number, fontInfo: FontInfo, disableMonospaceOptimizations: boolean, typicalHalfwidthCharacterWidth: number, scrollBeyondLastColumn: number, lineHeight: number, lineDecorationsWidth: number, stopRenderingLineAfter: number, renderWhitespace: FindComputedEditorOptionValueById<EditorOption.renderWhitespace>, renderControlCharacters: boolean, fontLigatures: FindComputedEditorOptionValueById<EditorOption.fontLigatures>, verticalScrollbarSize: number, useTwoCellFullwidthCharacters?: boolean, setWidth?: boolean);
     withSetWidth(setWidth: boolean): RenderOptions;
     withScrollBeyondLastColumn(scrollBeyondLastColumn: number): RenderOptions;
 }

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines.js

@@ -105,7 +105,8 @@ class RenderOptions {
             modifiedEditorOptions.get(EditorOption.renderWhitespace),
             modifiedEditorOptions.get(EditorOption.renderControlCharacters),
             modifiedEditorOptions.get(EditorOption.fontLigatures),
-            modifiedEditorOptions.get(EditorOption.scrollbar).verticalScrollbarSize
+            modifiedEditorOptions.get(EditorOption.scrollbar).verticalScrollbarSize,
+            modifiedEditorOptions.get(EditorOption.effectiveFullwidthCharacterWidth) === "twoCells"
         ));
     }
     constructor(
@@ -121,6 +122,7 @@ class RenderOptions {
         renderControlCharacters,
         fontLigatures,
         verticalScrollbarSize,
+        useTwoCellFullwidthCharacters = false,
         setWidth = true
     ) {
         this.tabSize = tabSize;
@@ -135,6 +137,7 @@ class RenderOptions {
         this.renderControlCharacters = renderControlCharacters;
         this.fontLigatures = fontLigatures;
         this.verticalScrollbarSize = verticalScrollbarSize;
+        this.useTwoCellFullwidthCharacters = useTwoCellFullwidthCharacters;
         this.setWidth = setWidth;
     }
     withSetWidth(setWidth) {
@@ -151,6 +154,7 @@ class RenderOptions {
             this.renderControlCharacters,
             this.fontLigatures,
             this.verticalScrollbarSize,
+            this.useTwoCellFullwidthCharacters,
             setWidth
         ));
     }
@@ -168,6 +172,7 @@ class RenderOptions {
             this.renderControlCharacters,
             this.fontLigatures,
             this.verticalScrollbarSize,
+            this.useTwoCellFullwidthCharacters,
             this.setWidth
         ));
     }
@@ -275,7 +280,9 @@ function renderOriginalLine(
         options.fontLigatures !== EditorFontLigatures.OFF,
         null,
         null,
-        options.verticalScrollbarSize
+        options.verticalScrollbarSize,
+        false,
+        options.useTwoCellFullwidthCharacters
     )), sb);
     sb.appendString("</div>");
     const maxCharWidth = output.characterMapping.getHorizontalOffset(output.characterMapping.length);

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

@@ -11,24 +11,10 @@ import './registrations.contribution.js';
 registerAction2(ToggleCollapseUnchangedRegions);
 registerAction2(ToggleShowMovedCodeBlocks);
 registerAction2(ToggleUseInlineViewWhenSpaceIsLimited);
-MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
-    command: {
-        id: ( new ToggleUseInlineViewWhenSpaceIsLimited()).desc.id,
-        title: ( localize(213, "Use Inline View When Space Is Limited")),
-        toggled: ( ContextKeyExpr.has("config.diffEditor.useInlineViewWhenSpaceIsLimited")),
-        precondition: ( ContextKeyExpr.has("isInDiffEditor"))
-    },
-    order: 11,
-    group: "1_diff",
-    when: ( ContextKeyExpr.and(
-        EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached,
-        ( ContextKeyExpr.has("isInDiffEditor"))
-    ))
-});
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
         id: ( new ToggleShowMovedCodeBlocks()).desc.id,
-        title: ( localize(214, "Show Moved Code Blocks")),
+        title: ( localize(213, "Show Moved Code Blocks")),
         icon: Codicon.move,
         toggled: ContextKeyEqualsExpr.create("config.diffEditor.experimental.showMoves", true),
         precondition: ( ContextKeyExpr.has("isInDiffEditor"))
@@ -48,7 +34,7 @@ for (const ctx of [{
     MenuRegistry.appendMenuItem(MenuId.DiffEditorHunkToolbar, {
         command: {
             id: ( new RevertHunkOrSelection()).desc.id,
-            title: ( localize(215, "Revert Block")),
+            title: ( localize(214, "Revert Block")),
             icon: ctx.icon
         },
         when: ( ContextKeyExpr.and(EditorContextKeys.diffEditorModifiedWritable, ctx.key)),
@@ -58,7 +44,7 @@ for (const ctx of [{
     MenuRegistry.appendMenuItem(MenuId.DiffEditorSelectionToolbar, {
         command: {
             id: ( new RevertHunkOrSelection()).desc.id,
-            title: ( localize(216, "Revert Selection")),
+            title: ( localize(215, "Revert Selection")),
             icon: ctx.icon
         },
         when: ( ContextKeyExpr.and(EditorContextKeys.diffEditorModifiedWritable, ctx.key)),
@@ -73,7 +59,7 @@ registerAction2(ShowAllUnchangedRegions);
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
         id: AccessibleDiffViewerNext.id,
-        title: ( localize(217, "Open Accessible Diff Viewer")),
+        title: ( localize(216, "Open Accessible Diff Viewer")),
         precondition: ( ContextKeyExpr.has("isInDiffEditor"))
     },
     order: 10,

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorOptions.d.ts

@@ -1,4 +1,4 @@
-import { IObservable, IObservableWithChange } from "../../../../base/common/observable.js";
+import { IObservable, IObservableWithChange, ITransaction } from "../../../../base/common/observable.js";
 import { IAccessibilityService } from "../../../../platform/accessibility/common/accessibility.service.js";
 import { IDiffEditorOptions, IEditorOptions } from "../../../common/config/editorOptions.js";
 import { DiffEditorViewModel } from "./diffEditorViewModel.js";
@@ -9,11 +9,14 @@ export declare class DiffEditorOptions {
         changedOptions: IEditorOptions;
     }>;
     private readonly _diffEditorWidth;
+    private readonly _widthBasedLayout;
     private readonly _screenReaderMode;
     constructor(options: Readonly<IDiffEditorOptions>, _accessibilityService: IAccessibilityService);
     readonly couldShowInlineViewBecauseOfSize: IObservableWithChange<boolean, void>;
     readonly renderOverviewRuler: IObservableWithChange<boolean, void>;
+    readonly renderSideBySideInAutomaticMode: IObservableWithChange<boolean, void>;
     readonly renderSideBySide: IObservableWithChange<boolean, void>;
+    readonly temporaryInlineMode: IObservable<boolean>;
     readonly readOnly: IObservableWithChange<boolean | undefined, void>;
     readonly shouldRenderOldRevertArrows: IObservableWithChange<boolean, void>;
     readonly shouldRenderGutterMenu: IObservableWithChange<boolean, void>;
@@ -24,11 +27,11 @@ export declare class DiffEditorOptions {
     readonly maxComputationTimeMs: IObservableWithChange<number, void>;
     readonly showMoves: IObservableWithChange<boolean, void>;
     readonly isInEmbeddedEditor: IObservableWithChange<boolean, void>;
-    readonly diffWordWrap: IObservableWithChange<"on" | "inherit" | "off", void>;
+    readonly diffWordWrap: IObservableWithChange<"inherit" | "off" | "on", void>;
     readonly originalEditable: IObservableWithChange<boolean, void>;
     readonly diffCodeLens: IObservableWithChange<boolean, void>;
     readonly accessibilityVerbose: IObservableWithChange<boolean, void>;
-    readonly diffAlgorithm: IObservableWithChange<"advanced" | "legacy" | "advanced-external" | "advanced-wasm", void>;
+    readonly diffAlgorithm: IObservableWithChange<"advanced" | "advanced-external" | "advanced-wasm" | "legacy", void>;
     readonly showEmptyDecorations: IObservableWithChange<boolean, void>;
     readonly onlyShowAccessibleDiffViewer: IObservableWithChange<boolean, void>;
     readonly compactMode: IObservableWithChange<boolean, void>;
@@ -39,7 +42,8 @@ export declare class DiffEditorOptions {
     readonly hideUnchangedRegionsContextLineCount: IObservableWithChange<number, void>;
     readonly hideUnchangedRegionsMinimumLineCount: IObservableWithChange<number, void>;
     updateOptions(changedOptions: IDiffEditorOptions): void;
-    setWidth(width: number): void;
+    setWidth(width: number, smoothResizeStartWidth?: number): void;
+    resetWidthBasedLayout(tx?: ITransaction): void;
     private readonly _model;
     setModel(model: DiffEditorViewModel | undefined): void;
     private readonly shouldRenderInlineViewInSmartMode;

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

@@ -10,6 +10,7 @@ import { observableValue } from '../../../../base/common/observableInternal/obse
 import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
 import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
 import { derivedConstOnceDefined } from '../../../../base/common/observableInternal/experimental/utils.js';
+import { transaction } from '../../../../base/common/observableInternal/transaction.js';
 
 let DiffEditorOptions = class DiffEditorOptions {
     get editorOptions() {
@@ -17,6 +18,8 @@ let DiffEditorOptions = class DiffEditorOptions {
     }
     constructor(options, _accessibilityService) {
         this._accessibilityService = _accessibilityService;
+        this._widthBasedLayout = observableValue(this, "auto");
+        this.temporaryInlineMode = ( this._widthBasedLayout.map(this, layout => layout === "inline"));
         this._diffEditorWidth = observableValue(this, 0);
         this._screenReaderMode = observableFromEvent(
             this,
@@ -28,13 +31,19 @@ let DiffEditorOptions = class DiffEditorOptions {
             reader => this._options.read(reader).renderSideBySide && this._diffEditorWidth.read(reader) <= this._options.read(reader).renderSideBySideInlineBreakpoint
         );
         this.renderOverviewRuler = derived(this, reader => this._options.read(reader).renderOverviewRuler);
+        this.renderSideBySideInAutomaticMode = derived(this, reader => {
+            if (this.compactMode.read(reader) && this.shouldRenderInlineViewInSmartMode.read(reader)) {
+                return false;
+            }
+            return this._diffEditorWidth.read(reader) > this._options.read(reader).renderSideBySideInlineBreakpoint || this._screenReaderMode.read(reader);
+        });
         this.renderSideBySide = derived(this, reader => {
             if (this.compactMode.read(reader)) {
                 if (this.shouldRenderInlineViewInSmartMode.read(reader)) {
                     return false;
                 }
             }
-            return this._options.read(reader).renderSideBySide && !(this._options.read(reader).useInlineViewWhenSpaceIsLimited && this.couldShowInlineViewBecauseOfSize.read(reader) && !this._screenReaderMode.read(reader));
+            return this._options.read(reader).renderSideBySide && this._widthBasedLayout.read(reader) === "auto" && !(this._options.read(reader).useInlineViewWhenSpaceIsLimited && this.couldShowInlineViewBecauseOfSize.read(reader) && !this._screenReaderMode.read(reader));
         });
         this.readOnly = derived(this, reader => this._options.read(reader).readOnly);
         this.shouldRenderOldRevertArrows = derived(this, reader => {
@@ -97,7 +106,10 @@ let DiffEditorOptions = class DiffEditorOptions {
             const diffs = model?.diff.read(reader);
             return diffs ? isSimpleDiff(diffs, this.trueInlineDiffRenderingEnabled.read(reader)) : undefined;
         }))).flatten().map(this, v => !!v));
-        this.inlineViewHideOriginalLineNumbers = this.compactMode;
+        this.inlineViewHideOriginalLineNumbers = derived(
+            this,
+            reader => this._options.read(reader).hideOriginalLineNumbers || this.compactMode.read(reader)
+        );
         const optionsCopy = {
             ...options,
             ...validateDiffEditorOptions(options, diffEditorDefaultOptions)
@@ -105,18 +117,35 @@ let DiffEditorOptions = class DiffEditorOptions {
         this._options = observableValue(this, optionsCopy);
     }
     updateOptions(changedOptions) {
+        const currentOptions = this._options.get();
         const newDiffEditorOptions = validateDiffEditorOptions(changedOptions, this._options.get());
         const newOptions = {
-            ...this._options.get(),
+            ...currentOptions,
             ...changedOptions,
             ...newDiffEditorOptions
         };
-        this._options.set(newOptions, undefined, {
-            changedOptions: changedOptions
+        transaction(tx => {
+            if (currentOptions.renderSideBySide !== newOptions.renderSideBySide || currentOptions.useInlineViewWhenSpaceIsLimited !== newOptions.useInlineViewWhenSpaceIsLimited || currentOptions.renderSideBySideInlineBreakpoint !== newOptions.renderSideBySideInlineBreakpoint) {
+                this._widthBasedLayout.set("auto", tx);
+            }
+            this._options.set(newOptions, tx, {
+                changedOptions: changedOptions
+            });
+        });
+    }
+    setWidth(width, smoothResizeStartWidth) {
+        const options = this._options.get();
+        transaction(tx => {
+            this._diffEditorWidth.set(width, tx);
+            if (width <= options.renderSideBySideInlineBreakpoint) {
+                this._widthBasedLayout.set("auto", tx);
+            } else if (smoothResizeStartWidth !== undefined && this._widthBasedLayout.get() === "auto" && options.renderSideBySide && options.useInlineViewWhenSpaceIsLimited && smoothResizeStartWidth <= options.renderSideBySideInlineBreakpoint && width > options.renderSideBySideInlineBreakpoint && !this._screenReaderMode.get() && !(this.compactMode.get() && this.shouldRenderInlineViewInSmartMode.get())) {
+                this._widthBasedLayout.set("inline", tx);
+            }
         });
     }
-    setWidth(width) {
-        this._diffEditorWidth.set(width, undefined);
+    resetWidthBasedLayout(tx) {
+        this._widthBasedLayout.set("auto", tx);
     }
     setModel(model) {
         this._model.set(model, undefined);
@@ -219,7 +248,8 @@ function validateDiffEditorOptions(options, defaults) {
             defaults.useInlineViewWhenSpaceIsLimited
         ),
         renderGutterMenu: boolean(options.renderGutterMenu, defaults.renderGutterMenu),
-        compactMode: boolean(options.compactMode, defaults.compactMode)
+        compactMode: boolean(options.compactMode, defaults.compactMode),
+        hideOriginalLineNumbers: boolean(options.hideOriginalLineNumbers, defaults.hideOriginalLineNumbers)
     };
 }
 

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorViewModel.d.ts

@@ -62,7 +62,7 @@ export declare class UnchangedRegion {
     private readonly _visibleLineCountBottom;
     readonly visibleLineCountBottom: ISettableObservable<number>;
     private readonly _shouldHideControls;
-    readonly isDragged: ISettableObservable<"top" | "bottom" | undefined, void>;
+    readonly isDragged: ISettableObservable<"bottom" | "top" | undefined, void>;
     constructor(originalLineNumber: number, modifiedLineNumber: number, lineCount: number, visibleLineCountTop: number, visibleLineCountBottom: number);
     setVisibleRanges(visibleRanges: LineRangeMapping[], tx: ITransaction): UnchangedRegion[];
     shouldHideControls(reader: IReader | undefined): boolean;

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorWidget.d.ts

@@ -1,6 +1,6 @@
 import { IBoundarySashes } from "../../../../base/browser/ui/sash/sash.js";
 import { Event } from "../../../../base/common/event.js";
-import { ITransaction } from "../../../../base/common/observable.js";
+import { IObservable, ITransaction } from "../../../../base/common/observable.js";
 import { IAccessibilitySignalService } from "../../../../platform/accessibilitySignal/browser/accessibilitySignalService.service.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
@@ -22,6 +22,8 @@ import { RefCounted } from "./utils.js";
 export interface IDiffCodeEditorWidgetOptions {
     originalEditor?: ICodeEditorWidgetOptions;
     modifiedEditor?: ICodeEditorWidgetOptions;
+    runWithOriginalEditorScrollAnchor?: (anchorLineNumber: number, update: () => void) => void;
+    runWithModifiedEditorScrollAnchor?: (anchorLineNumber: number, update: () => void) => void;
     /**
      * Is this a standalone editor
      * Defaults to false.
@@ -40,6 +42,7 @@ export declare class DiffEditorWidget extends DelegatingEditor implements IDiffE
     private readonly elements;
     private readonly _diffModelSrc;
     private readonly _diffModel;
+    private readonly _deferredDiffModelRefDisposals;
     readonly onDidChangeModel: Event<void>;
     get onDidContentSizeChange(): Event<import("../../../common/editorCommon.js").IContentSizeChangedEvent>;
     private readonly _contextKeyService;
@@ -57,6 +60,13 @@ export declare class DiffEditorWidget extends DelegatingEditor implements IDiffE
     private readonly _movedBlocksLinesPart;
     private readonly _gutter;
     get collapseUnchangedRegions(): boolean;
+    /**
+     * `true` when every hidden-unchanged region of the current diff is fully
+     * revealed (or there are none). Read by `DiffEditorItemTemplate` to drive the
+     * multi-diff per-file expand/collapse toggle. Not external API.
+     * @internal
+     */
+    readonly allUnchangedRegionsShown: IObservable<boolean>;
     constructor(_domElement: HTMLElement, options: Readonly<IDiffEditorConstructionOptions>, codeEditorWidgetOptions: IDiffCodeEditorWidgetOptions, _parentContextKeyService: IContextKeyService, _parentInstantiationService: IInstantiationService, _codeEditorService: ICodeEditorService, _accessibilitySignalService: IAccessibilitySignalService, _editorProgressService: IEditorProgressService, keybindingService: IKeybindingService);
     getViewWidth(): number;
     getContentHeight(): number;
@@ -90,6 +100,9 @@ export declare class DiffEditorWidget extends DelegatingEditor implements IDiffE
     get ignoreTrimWhitespace(): boolean;
     get maxComputationTime(): number;
     get renderSideBySide(): boolean;
+    get renderSideBySideInAutomaticMode(): IObservable<boolean>;
+    get temporaryInlineMode(): IObservable<boolean>;
+    resetWidthBasedLayout(): void;
     /**
      * @deprecated Use `this.getDiffComputationResult().changes2` instead.
      */

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

@@ -1,12 +1,13 @@
 
 import { registerCss } from '../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { h, getWindow } from '../../../../base/browser/dom.js';
+import { h, getWindow, addDisposableListener } from '../../../../base/browser/dom.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
 import { findLast } from '../../../../base/common/arraysFind.js';
 import { onUnexpectedError, BugIndicatingError } from '../../../../base/common/errors.js';
 import { Event } from '../../../../base/common/event.js';
 import { readHotReloadableExport } from '../../../../base/common/hotReloadHelpers.js';
-import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import '../../../../base/common/observableInternal/index.js';
 import { AccessibilitySignal } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
 import { IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.service.js';
@@ -78,6 +79,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._accessibilitySignalService = _accessibilitySignalService;
         this._editorProgressService = _editorProgressService;
         this.keybindingService = keybindingService;
+        this._deferredDiffModelRefDisposals = this._register(( new DisposableStore()));
         this.elements = h("div.monaco-diff-editor.side-by-side", {
             style: {
                 position: "relative",
@@ -101,6 +103,12 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         })]);
         this._diffModelSrc = this._register(disposableObservableValue(this, undefined));
         this._diffModel = derived(this, reader => this._diffModelSrc.read(reader)?.object);
+        this.allUnchangedRegionsShown = derived(this, reader => {
+            const regions = this._diffModel.read(reader)?.unchangedRegions.read(reader) ?? [];
+            return regions.every(
+                r => r.visibleLineCountTop.read(reader) + r.visibleLineCountBottom.read(reader) >= r.lineCount
+            );
+        });
         this.onDidChangeModel = Event.fromObservableLight(this._diffModel);
         this._contextKeyService = this._register(this._parentContextKeyService.createScoped(this._domElement));
         this._instantiationService = this._register(this._parentInstantiationService.createChild(( new ServiceCollection([IContextKeyService, this._contextKeyService]))));
@@ -173,8 +181,55 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._rootSizeObserver = this._register(( new ObservableElementSizeObserver(this.elements.root, options.dimension)));
         this._rootSizeObserver.setAutomaticLayout(options.automaticLayout ?? false);
         this._options = this._instantiationService.createInstance(DiffEditorOptions, options);
+        let lastWidth;
+        let resizeStartWidth;
+        let windowResizeEventCount = 0;
+        let resizeWasPointerDriven = false;
+        let pointerDown = false;
+        const finishSmoothResize = () => {
+            if (pointerDown) {
+                smoothResizeScheduler.schedule();
+                return;
+            }
+            resizeStartWidth = undefined;
+            windowResizeEventCount = 0;
+            resizeWasPointerDriven = false;
+        };
+        const smoothResizeScheduler = this._register(( new RunOnceScheduler(finishSmoothResize, 200)));
+        const targetWindow = getWindow(this._domElement);
+        this._register(addDisposableListener(targetWindow, "resize", () => {
+            windowResizeEventCount++;
+            smoothResizeScheduler.schedule();
+        }));
+        const onPointerDown = () => pointerDown = true;
+        const onPointerUp = () => {
+            if (!pointerDown) {
+                return;
+            }
+            pointerDown = false;
+            smoothResizeScheduler.cancel();
+            finishSmoothResize();
+        };
+        this._register(addDisposableListener(targetWindow, "mousedown", onPointerDown, true));
+        this._register(addDisposableListener(targetWindow, "mouseup", onPointerUp, true));
+        this._register(addDisposableListener(targetWindow, "touchstart", onPointerDown, true));
+        this._register(addDisposableListener(targetWindow, "touchend", onPointerUp, true));
+        this._register(addDisposableListener(targetWindow, "touchcancel", onPointerUp, true));
         this._register(autorun(reader => {
-            this._options.setWidth(this._rootSizeObserver.width.read(reader));
+            const width = this._rootSizeObserver.width.read(reader);
+            let smoothResizeStartWidth;
+            if (lastWidth !== undefined && width !== lastWidth) {
+                if (resizeStartWidth === undefined) {
+                    resizeStartWidth = lastWidth;
+                }
+                resizeWasPointerDriven ||= pointerDown;
+                if (resizeStartWidth !== undefined && (resizeWasPointerDriven || windowResizeEventCount > 1)) {
+                    smoothResizeStartWidth = resizeStartWidth;
+                }
+                smoothResizeScheduler.schedule();
+            }
+            this._options.setWidth(width, smoothResizeStartWidth);
+            lastWidth = width;
         }));
         this._contextKeyService.createKey(EditorContextKeys.isEmbeddedDiffEditor.key, false);
         this._register(bindContextKey(
@@ -197,6 +252,16 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
             this._contextKeyService,
             reader => !this._options.renderSideBySide.read(reader)
         ));
+        this._register(bindContextKey(
+            EditorContextKeys.diffEditorTemporaryInlineMode,
+            this._contextKeyService,
+            reader => this._options.temporaryInlineMode.read(reader)
+        ));
+        this._register(bindContextKey(
+            EditorContextKeys.diffEditorAutomaticRenderSideBySide,
+            this._contextKeyService,
+            reader => this._options.renderSideBySideInAutomaticMode.read(reader)
+        ));
         this._register(bindContextKey(
             EditorContextKeys.hasChanges,
             this._contextKeyService,
@@ -265,7 +330,9 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
                 readHotReloadableExport(HideUnchangedRegionsFeature),
                 this._editors,
                 this._diffModel,
-                this._options
+                this._options,
+                codeEditorWidgetOptions.runWithOriginalEditorScrollAnchor,
+                codeEditorWidgetOptions.runWithModifiedEditorScrollAnchor
             )
         ).recomputeInitiallyAndOnChange(this._store);
         derivedDisposable(
@@ -409,7 +476,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         return this._rootSizeObserver.width.get();
     }
     getContentHeight() {
-        return this._editors.modified.getContentHeight();
+        return this._editors.getContentHeight();
     }
     _createInnerEditor(instantiationService, container, options, editorWidgetOptions) {
         const editor = instantiationService.createInstance(CodeEditorWidget, container, options, editorWidgetOptions);
@@ -486,15 +553,21 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         if (this._diffModel.get() !== viewModel?.object) {
             subtransaction(tx, tx => {
                 const vm = viewModel?.object;
+                if (currentModel?.model.original !== vm?.model.original || currentModel?.model.modified !== vm?.model.modified) {
+                    this._options.resetWidthBasedLayout(tx);
+                }
                 observableFromEvent.batchEventsGlobally(tx, () => {
                     this._editors.original.setModel(vm ? vm.model.original : null);
                     this._editors.modified.setModel(vm ? vm.model.modified : null);
                 });
                 const prevValueRef = this._diffModelSrc.get()?.createNewRef(this);
                 this._diffModelSrc.set(viewModel?.createNewRef(this), tx);
-                setTimeout(() => {
-                    prevValueRef?.dispose();
-                }, 0);
+                if (prevValueRef) {
+                    this._deferredDiffModelRefDisposals.add(prevValueRef);
+                    setTimeout(() => {
+                        this._deferredDiffModelRefDisposals.delete(prevValueRef);
+                    }, 0);
+                }
             });
         }
     }
@@ -525,6 +598,15 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
     get renderSideBySide() {
         return this._options.renderSideBySide.get();
     }
+    get renderSideBySideInAutomaticMode() {
+        return this._options.renderSideBySideInAutomaticMode;
+    }
+    get temporaryInlineMode() {
+        return this._options.temporaryInlineMode;
+    }
+    resetWidthBasedLayout() {
+        this._options.resetWidthBasedLayout();
+    }
     getLineChanges() {
         const diffState = this._diffModel.get()?.diff.get();
         if (!diffState) {

package/vscode/src/vs/editor/browser/widget/diffEditor/features/hideUnchangedRegionsFeature.d.ts

@@ -15,6 +15,8 @@ export declare class HideUnchangedRegionsFeature extends Disposable {
     private readonly _editors;
     private readonly _diffModel;
     private readonly _options;
+    private readonly _runWithOriginalEditorScrollAnchor;
+    private readonly _runWithModifiedEditorScrollAnchor;
     private readonly _instantiationService;
     static readonly _breadcrumbsSourceFactory: import("../../../../../base/common/observable.js").ISettableObservable<(textModel: ITextModel, instantiationService: IInstantiationService) => IDiffEditorBreadcrumbsSource, void>;
     static setBreadcrumbsSourceFactory(factory: (textModel: ITextModel, instantiationService: IInstantiationService) => IDiffEditorBreadcrumbsSource): void;
@@ -25,7 +27,7 @@ export declare class HideUnchangedRegionsFeature extends Disposable {
     }>;
     private _isUpdatingHiddenAreas;
     get isUpdatingHiddenAreas(): boolean;
-    constructor(_editors: DiffEditorEditors, _diffModel: IObservable<DiffEditorViewModel | undefined>, _options: DiffEditorOptions, _instantiationService: IInstantiationService);
+    constructor(_editors: DiffEditorEditors, _diffModel: IObservable<DiffEditorViewModel | undefined>, _options: DiffEditorOptions, _runWithOriginalEditorScrollAnchor: ((anchorLineNumber: number, update: () => void) => void) | undefined, _runWithModifiedEditorScrollAnchor: ((anchorLineNumber: number, update: () => void) => void) | undefined, _instantiationService: IInstantiationService);
 }
 export interface IDiffEditorBreadcrumbsSource extends IDisposable {
     getBreadcrumbItems(startRange: LineRange, reader: IReader): {