@codingame/monaco-vscode-api 3.2.2 → 4.0.0

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

@@ -1,79 +1,13 @@
-import { getActiveElement } from '../../../../base/browser/dom.js';
 import { Codicon } from '../../../../base/common/codicons.js';
-import { EditorAction2 } from '../../editorExtensions.js';
-import { ICodeEditorService } from '../../services/codeEditorService.js';
-import { DiffEditorWidget } from './diffEditorWidget.js';
+import { ToggleUseInlineViewWhenSpaceIsLimited, ToggleShowMovedCodeBlocks, RevertHunkOrSelection, AccessibleDiffViewerNext, AccessibleDiffViewerPrev, ToggleCollapseUnchangedRegions, SwitchSide, ExitCompareMove, CollapseAllUnchangedRegions, ShowAllUnchangedRegions } from './commands.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import { registerAction2, MenuRegistry, MenuId, Action2 } from '../../../../platform/actions/common/actions.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerAction2, MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
 import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
 import { ContextKeyExpr, ContextKeyEqualsExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import './registrations.contribution.js';
-class ToggleCollapseUnchangedRegions extends Action2 {
-    constructor() {
-        super({
-            id: 'diffEditor.toggleCollapseUnchangedRegions',
-            title: ( localize2WithPath(
-                'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'toggleCollapseUnchangedRegions',
-                'Toggle Collapse Unchanged Regions'
-            )),
-            icon: Codicon.map,
-            toggled: ( ContextKeyExpr.has('config.diffEditor.hideUnchangedRegions.enabled')),
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-            menu: {
-                when: ( ContextKeyExpr.has('isInDiffEditor')),
-                id: MenuId.EditorTitle,
-                order: 22,
-                group: 'navigation',
-            },
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.hideUnchangedRegions.enabled');
-        configurationService.updateValue('diffEditor.hideUnchangedRegions.enabled', newValue);
-    }
-}
 registerAction2(ToggleCollapseUnchangedRegions);
-class ToggleShowMovedCodeBlocks extends Action2 {
-    constructor() {
-        super({
-            id: 'diffEditor.toggleShowMovedCodeBlocks',
-            title: ( localize2WithPath(
-                'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'toggleShowMovedCodeBlocks',
-                'Toggle Show Moved Code Blocks'
-            )),
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.experimental.showMoves');
-        configurationService.updateValue('diffEditor.experimental.showMoves', newValue);
-    }
-}
 registerAction2(ToggleShowMovedCodeBlocks);
-class ToggleUseInlineViewWhenSpaceIsLimited extends Action2 {
-    constructor() {
-        super({
-            id: 'diffEditor.toggleUseInlineViewWhenSpaceIsLimited',
-            title: ( localize2WithPath(
-                'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'toggleUseInlineViewWhenSpaceIsLimited',
-                'Toggle Use Inline View When Space Is Limited'
-            )),
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.useInlineViewWhenSpaceIsLimited');
-        configurationService.updateValue('diffEditor.useInlineViewWhenSpaceIsLimited', newValue);
-    }
-}
 registerAction2(ToggleUseInlineViewWhenSpaceIsLimited);
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
@@ -109,142 +43,44 @@ MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     group: '1_diff',
     when: ( ContextKeyExpr.has('isInDiffEditor')),
 });
-const diffEditorCategory = ( localize2WithPath(
-    'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-    'diffEditor',
-    "Diff Editor"
-));
-class SwitchSide extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.switchSide',
-            title: ( localize2WithPath(
+registerAction2(RevertHunkOrSelection);
+for (const ctx of [
+    { icon: Codicon.arrowRight, key: ( EditorContextKeys.diffEditorInlineMode.toNegated()) },
+    { icon: Codicon.discard, key: EditorContextKeys.diffEditorInlineMode }
+]) {
+    MenuRegistry.appendMenuItem(MenuId.DiffEditorHunkToolbar, {
+        command: {
+            id: ( new RevertHunkOrSelection()).desc.id,
+            title: ( localizeWithPath(
                 'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'switchSide',
-                'Switch Side'
+                'revertHunk',
+                "Revert Block"
             )),
-            icon: Codicon.arrowSwap,
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-            f1: true,
-            category: diffEditorCategory,
-        });
-    }
-    runEditorCommand(accessor, editor, arg) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget) {
-            if (arg && arg.dryRun) {
-                return { destinationSelection: diffEditor.mapToOtherSide().destinationSelection };
-            }
-            else {
-                diffEditor.switchSide();
-            }
-        }
-        return undefined;
-    }
-}
-registerAction2(SwitchSide);
-class ExitCompareMove extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.exitCompareMove',
-            title: ( localize2WithPath(
+            icon: ctx.icon,
+        },
+        when: ( ContextKeyExpr.and(EditorContextKeys.diffEditorModifiedWritable, ctx.key)),
+        order: 5,
+        group: 'primary',
+    });
+    MenuRegistry.appendMenuItem(MenuId.DiffEditorSelectionToolbar, {
+        command: {
+            id: ( new RevertHunkOrSelection()).desc.id,
+            title: ( localizeWithPath(
                 'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'exitCompareMove',
-                'Exit Compare Move'
+                'revertSelection',
+                "Revert Selection"
             )),
-            icon: Codicon.close,
-            precondition: EditorContextKeys.comparingMovedCode,
-            f1: false,
-            category: diffEditorCategory,
-            keybinding: {
-                weight: 10000,
-                primary: 9 ,
-            }
-        });
-    }
-    runEditorCommand(accessor, editor, ...args) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget) {
-            diffEditor.exitCompareMove();
-        }
-    }
+            icon: ctx.icon,
+        },
+        when: ( ContextKeyExpr.and(EditorContextKeys.diffEditorModifiedWritable, ctx.key)),
+        order: 5,
+        group: 'primary',
+    });
 }
+registerAction2(SwitchSide);
 registerAction2(ExitCompareMove);
-class CollapseAllUnchangedRegions extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.collapseAllUnchangedRegions',
-            title: ( localize2WithPath(
-                'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'collapseAllUnchangedRegions',
-                'Collapse All Unchanged Regions'
-            )),
-            icon: Codicon.fold,
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-            f1: true,
-            category: diffEditorCategory,
-        });
-    }
-    runEditorCommand(accessor, editor, ...args) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget) {
-            diffEditor.collapseAllUnchangedRegions();
-        }
-    }
-}
 registerAction2(CollapseAllUnchangedRegions);
-class ShowAllUnchangedRegions extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.showAllUnchangedRegions',
-            title: ( localize2WithPath(
-                'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'showAllUnchangedRegions',
-                'Show All Unchanged Regions'
-            )),
-            icon: Codicon.unfold,
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-            f1: true,
-            category: diffEditorCategory,
-        });
-    }
-    runEditorCommand(accessor, editor, ...args) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget) {
-            diffEditor.showAllUnchangedRegions();
-        }
-    }
-}
 registerAction2(ShowAllUnchangedRegions);
-const accessibleDiffViewerCategory = ( localize2WithPath(
-    'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-    'accessibleDiffViewer',
-    "Accessible Diff Viewer"
-));
-class AccessibleDiffViewerNext extends Action2 {
-    static { this.id = 'editor.action.accessibleDiffViewer.next'; }
-    constructor() {
-        super({
-            id: AccessibleDiffViewerNext.id,
-            title: ( localize2WithPath(
-                'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'editor.action.accessibleDiffViewer.next',
-                'Go to Next Difference'
-            )),
-            category: accessibleDiffViewerCategory,
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-            keybinding: {
-                primary: 65 ,
-                weight: 100
-            },
-            f1: true,
-        });
-    }
-    run(accessor) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        diffEditor?.accessibleDiffViewerNext();
-    }
-}
 MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     command: {
         id: AccessibleDiffViewerNext.id,
@@ -259,56 +95,7 @@ MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
     group: '2_diff',
     when: ( ContextKeyExpr.and(( EditorContextKeys.accessibleDiffViewerVisible.negate()), ( ContextKeyExpr.has('isInDiffEditor')))),
 });
-class AccessibleDiffViewerPrev extends Action2 {
-    static { this.id = 'editor.action.accessibleDiffViewer.prev'; }
-    constructor() {
-        super({
-            id: AccessibleDiffViewerPrev.id,
-            title: ( localize2WithPath(
-                'vs/editor/browser/widget/diffEditor/diffEditor.contribution',
-                'editor.action.accessibleDiffViewer.prev',
-                'Go to Previous Difference'
-            )),
-            category: accessibleDiffViewerCategory,
-            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
-            keybinding: {
-                primary: 1024  | 65 ,
-                weight: 100
-            },
-            f1: true,
-        });
-    }
-    run(accessor) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        diffEditor?.accessibleDiffViewerPrev();
-    }
-}
-function findFocusedDiffEditor(accessor) {
-    const codeEditorService = accessor.get(ICodeEditorService);
-    const diffEditors = codeEditorService.listDiffEditors();
-    const activeElement = getActiveElement();
-    if (activeElement) {
-        for (const d of diffEditors) {
-            const container = d.getContainerDomNode();
-            if (isElementOrParentOf(container, activeElement)) {
-                return d;
-            }
-        }
-    }
-    return null;
-}
-function isElementOrParentOf(elementOrParent, element) {
-    let e = element;
-    while (e) {
-        if (e === elementOrParent) {
-            return true;
-        }
-        e = e.parentElement;
-    }
-    return false;
-}
 CommandsRegistry.registerCommandAlias('editor.action.diffReview.next', AccessibleDiffViewerNext.id);
 registerAction2(AccessibleDiffViewerNext);
 CommandsRegistry.registerCommandAlias('editor.action.diffReview.prev', AccessibleDiffViewerPrev.id);
 registerAction2(AccessibleDiffViewerPrev);
-export { AccessibleDiffViewerNext, AccessibleDiffViewerPrev, CollapseAllUnchangedRegions, ExitCompareMove, ShowAllUnchangedRegions, SwitchSide, ToggleCollapseUnchangedRegions, ToggleShowMovedCodeBlocks, ToggleUseInlineViewWhenSpaceIsLimited, findFocusedDiffEditor };

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

@@ -1,17 +1,24 @@
-import { diffEditorDefaultOptions } from '../../../common/config/diffEditor.js';
-import { boolean, clampedFloat, clampedInt, stringSet } from '../../../common/config/editorOptions.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { observableValue } from '../../../../base/common/observableInternal/base.js';
 import { derived } from '../../../../base/common/observableInternal/derived.js';
-class DiffEditorOptions {
+import '../../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
+import { diffEditorDefaultOptions } from '../../../common/config/diffEditor.js';
+import { boolean, clampedFloat, clampedInt, stringSet } from '../../../common/config/editorOptions.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+let DiffEditorOptions = class DiffEditorOptions {
     get editorOptions() { return this._options; }
-    constructor(options) {
+    constructor(options, _accessibilityService) {
+        this._accessibilityService = _accessibilityService;
         this._diffEditorWidth = observableValue(this, 0);
+        this._screenReaderMode = observableFromEvent(this._accessibilityService.onDidChangeScreenReaderOptimized, () => this._accessibilityService.isScreenReaderOptimized());
         this.couldShowInlineViewBecauseOfSize = derived(this, 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.renderSideBySide = derived(this, reader => this._options.read(reader).renderSideBySide
-            && !(this._options.read(reader).useInlineViewWhenSpaceIsLimited && this.couldShowInlineViewBecauseOfSize.read(reader)));
+            && !(this._options.read(reader).useInlineViewWhenSpaceIsLimited && this.couldShowInlineViewBecauseOfSize.read(reader) && !this._screenReaderMode.read(reader)));
         this.readOnly = derived(this, reader => this._options.read(reader).readOnly);
-        this.shouldRenderRevertArrows = derived(this, reader => {
+        this.shouldRenderOldRevertArrows = derived(this, reader => {
             if (!this._options.read(reader).renderMarginRevertIcon) {
                 return false;
             }
@@ -21,8 +28,12 @@ class DiffEditorOptions {
             if (this.readOnly.read(reader)) {
                 return false;
             }
+            if (this.shouldRenderGutterMenu.read(reader)) {
+                return false;
+            }
             return true;
         });
+        this.shouldRenderGutterMenu = derived(this, reader => this._options.read(reader).renderGutterMenu);
         this.renderIndicators = derived(this, reader => this._options.read(reader).renderIndicators);
         this.enableSplitViewResizing = derived(this, reader => this._options.read(reader).enableSplitViewResizing);
         this.splitViewDefaultRatio = derived(this, reader => this._options.read(reader).splitViewDefaultRatio);
@@ -52,7 +63,10 @@ class DiffEditorOptions {
     setWidth(width) {
         this._diffEditorWidth.set(width, undefined);
     }
-}
+};
+DiffEditorOptions = ( __decorate([
+    ( __param(1, IAccessibilityService))
+], DiffEditorOptions));
 function validateDiffEditorOptions(options, defaults) {
     return {
         enableSplitViewResizing: boolean(options.enableSplitViewResizing, defaults.enableSplitViewResizing),
@@ -83,6 +97,7 @@ function validateDiffEditorOptions(options, defaults) {
         onlyShowAccessibleDiffViewer: boolean(options.onlyShowAccessibleDiffViewer, defaults.onlyShowAccessibleDiffViewer),
         renderSideBySideInlineBreakpoint: clampedInt(options.renderSideBySideInlineBreakpoint, defaults.renderSideBySideInlineBreakpoint, 0, 1073741824 ),
         useInlineViewWhenSpaceIsLimited: boolean(options.useInlineViewWhenSpaceIsLimited, defaults.useInlineViewWhenSpaceIsLimited),
+        renderGutterMenu: boolean(options.renderGutterMenu, defaults.renderGutterMenu),
     };
 }
 export { DiffEditorOptions };

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

@@ -2,6 +2,11 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { RunOnceScheduler } from '../../../../base/common/async.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { observableValue, transaction } from '../../../../base/common/observableInternal/base.js';
+import { derived } from '../../../../base/common/observableInternal/derived.js';
+import { autorun, autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
+import { observableSignalFromEvent, observableSignal } from '../../../../base/common/observableInternal/utils.js';
+import { waitForState } from '../../../../base/common/observableInternal/promise.js';
 import { IDiffProviderFactoryService } from './diffProviderFactoryService.js';
 import { readHotReloadableExport, filterWithPrevious } from './utils.js';
 import { LineRange, LineRangeSet } from '../../../common/core/lineRange.js';
@@ -13,11 +18,6 @@ import { optimizeSequenceDiffs } from '../../../common/diff/defaultLinesDiffComp
 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 { autorun, autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
-import { waitForState } from '../../../../base/common/observableInternal/promise.js';
-import { observableSignalFromEvent, observableSignal } from '../../../../base/common/observableInternal/utils.js';
 let DiffEditorViewModel = class DiffEditorViewModel extends Disposable {
     setActiveMovedText(movedText) {
         this._activeMovedText.set(movedText, undefined);

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

@@ -4,19 +4,24 @@ import { findLast } from '../../../../base/common/arraysFind.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Event } from '../../../../base/common/event.js';
 import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { observableValue, subtransaction, transaction } from '../../../../base/common/observableInternal/base.js';
 import { derived, derivedDisposable } from '../../../../base/common/observableInternal/derived.js';
+import { autorun, autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
+import { recomputeInitiallyAndOnChange, observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
 import './style.css.js';
 import { EditorExtensionsRegistry } from '../../editorExtensions.js';
 import { ICodeEditorService } from '../../services/codeEditorService.js';
 import { StableEditorScrollState } from '../../stableEditorScroll.js';
-import { CodeEditorWidget } from '../codeEditorWidget.js';
+import { CodeEditorWidget } from '../codeEditor/codeEditorWidget.js';
 import { AccessibleDiffViewerModelFromEditors, 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 { HideUnchangedRegionsFeature } from './features/hideUnchangedRegionsFeature.js';
 import { MovedBlocksLinesFeature } from './features/movedBlocksLinesFeature.js';
 import { OverviewRulerFeature } from './features/overviewRulerFeature.js';
+import { RevertButtonsFeature } from './features/revertButtonsFeature.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,14 +32,11 @@ 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 { DelegatingEditor } from './delegatingEditorImpl.js';
 import { DiffEditorEditors } from './components/diffEditorEditors.js';
+import { DelegatingEditor } from './delegatingEditorImpl.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';
+import { DiffEditorGutter } from './features/gutterFeature.js';
 let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
     static { this.ENTIRE_DIFF_OVERVIEW_WIDTH = OverviewRulerFeature.ENTIRE_DIFF_OVERVIEW_WIDTH; }
     get onDidContentSizeChange() { return this._editors.onDidContentSizeChange; }
@@ -48,8 +50,8 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._editorProgressService = _editorProgressService;
         this.elements = h('div.monaco-diff-editor.side-by-side', { style: { position: 'relative', height: '100%' } }, [
             h('div.noModificationsOverlay@overlay', { style: { position: 'absolute', height: '100%', visibility: 'hidden', } }, [$('span', {}, 'No Changes')]),
-            h('div.editor.original@original', { style: { position: 'absolute', height: '100%' } }),
-            h('div.editor.modified@modified', { style: { position: 'absolute', height: '100%' } }),
+            h('div.editor.original@original', { style: { position: 'absolute', height: '100%', zIndex: '1', } }),
+            h('div.editor.modified@modified', { style: { position: 'absolute', height: '100%', zIndex: '1', } }),
             h('div.accessibleDiffViewer@accessibleDiffViewer', { style: { position: 'absolute', height: '100%' } }),
         ]);
         this._diffModel = observableValue(this, undefined);
@@ -64,19 +66,37 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
             : this._accessibleDiffViewerShouldBeVisible.read(reader));
         this._movedBlocksLinesPart = observableValue(this, undefined);
         this._layoutInfo = derived(this, reader => {
-            const width = this._rootSizeObserver.width.read(reader);
-            const height = this._rootSizeObserver.height.read(reader);
-            const sashLeft = this._sash.read(reader)?.sashLeft.read(reader);
-            const originalWidth = sashLeft ?? Math.max(5, this._editors.original.getLayoutInfo().decorationsLeft);
-            const modifiedWidth = width - originalWidth - (this._overviewRulerPart.read(reader)?.width ?? 0);
-            const movedBlocksLinesWidth = this._movedBlocksLinesPart.read(reader)?.width.read(reader) ?? 0;
-            const originalWidthWithoutMovedBlockLines = originalWidth - movedBlocksLinesWidth;
-            this.elements.original.style.width = originalWidthWithoutMovedBlockLines + 'px';
-            this.elements.original.style.left = '0px';
+            const fullWidth = this._rootSizeObserver.width.read(reader);
+            const fullHeight = this._rootSizeObserver.height.read(reader);
+            const sash = this._sash.read(reader);
+            const gutter = this._gutter.read(reader);
+            const gutterWidth = gutter?.width.read(reader) ?? 0;
+            const overviewRulerPartWidth = this._overviewRulerPart.read(reader)?.width ?? 0;
+            let originalLeft, originalWidth, modifiedLeft, modifiedWidth, gutterLeft;
+            const sideBySide = !!sash;
+            if (sideBySide) {
+                const sashLeft = sash.sashLeft.read(reader);
+                const movedBlocksLinesWidth = this._movedBlocksLinesPart.read(reader)?.width.read(reader) ?? 0;
+                originalLeft = 0;
+                originalWidth = sashLeft - gutterWidth - movedBlocksLinesWidth;
+                gutterLeft = sashLeft - gutterWidth;
+                modifiedLeft = sashLeft;
+                modifiedWidth = fullWidth - modifiedLeft - overviewRulerPartWidth;
+            }
+            else {
+                gutterLeft = 0;
+                originalLeft = gutterWidth;
+                originalWidth = Math.max(5, this._editors.original.getLayoutInfo().decorationsLeft);
+                modifiedLeft = gutterWidth + originalWidth;
+                modifiedWidth = fullWidth - modifiedLeft - overviewRulerPartWidth;
+            }
+            this.elements.original.style.left = originalLeft + 'px';
+            this.elements.original.style.width = originalWidth + 'px';
+            this._editors.original.layout({ width: originalWidth, height: fullHeight }, true);
+            gutter?.layout(gutterLeft);
+            this.elements.modified.style.left = modifiedLeft + 'px';
             this.elements.modified.style.width = modifiedWidth + 'px';
-            this.elements.modified.style.left = originalWidth + 'px';
-            this._editors.original.layout({ width: originalWidthWithoutMovedBlockLines, height }, true);
-            this._editors.modified.layout({ width: modifiedWidth, height }, true);
+            this._editors.modified.layout({ width: modifiedWidth, height: fullHeight }, true);
             return {
                 modifiedEditor: this._editors.modified.getLayoutInfo(),
                 originalEditor: this._editors.original.getLayoutInfo(),
@@ -91,7 +111,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._register(toDisposable(() => this._domElement.removeChild(this.elements.root)));
         this._rootSizeObserver = this._register(( new ObservableElementSizeObserver(this.elements.root, options.dimension)));
         this._rootSizeObserver.setAutomaticLayout(options.automaticLayout ?? false);
-        this._options = ( new DiffEditorOptions(options));
+        this._options = this._instantiationService.createInstance(DiffEditorOptions, options);
         this._register(autorun(reader => {
             this._options.setWidth(this._rootSizeObserver.width.read(reader));
         }));
@@ -99,8 +119,13 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._register(bindContextKey(EditorContextKeys.isEmbeddedDiffEditor, this._contextKeyService, reader => this._options.isInEmbeddedEditor.read(reader)));
         this._register(bindContextKey(EditorContextKeys.comparingMovedCode, this._contextKeyService, reader => !!this._diffModel.read(reader)?.movedTextToCompare.read(reader)));
         this._register(bindContextKey(EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached, this._contextKeyService, reader => this._options.couldShowInlineViewBecauseOfSize.read(reader)));
+        this._register(bindContextKey(EditorContextKeys.diffEditorInlineMode, this._contextKeyService, reader => !this._options.renderSideBySide.read(reader)));
         this._register(bindContextKey(EditorContextKeys.hasChanges, this._contextKeyService, reader => (this._diffModel.read(reader)?.diff.read(reader)?.mappings.length ?? 0) > 0));
         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._register(bindContextKey(EditorContextKeys.diffEditorOriginalWritable, this._contextKeyService, reader => this._options.originalEditable.read(reader)));
+        this._register(bindContextKey(EditorContextKeys.diffEditorModifiedWritable, this._contextKeyService, reader => !this._options.readOnly.read(reader)));
+        this._register(bindContextKey(EditorContextKeys.diffEditorOriginalUri, this._contextKeyService, reader => this._diffModel.read(reader)?.model.original.uri.toString() ?? ''));
+        this._register(bindContextKey(EditorContextKeys.diffEditorModifiedUri, this._contextKeyService, reader => this._diffModel.read(reader)?.model.modified.uri.toString() ?? ''));
         this._overviewRulerPart = derivedDisposable(this, reader => !this._options.renderOverviewRuler.read(reader)
             ? undefined
             : 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);
@@ -148,6 +173,11 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this._register(applyStyle(this.elements.original, { visibility }));
         this._createDiffEditorContributions();
         codeEditorService.addDiffEditor(this);
+        this._gutter = derivedDisposable(this, reader => {
+            return this._options.shouldRenderGutterMenu.read(reader)
+                ? this._instantiationService.createInstance(readHotReloadableExport(DiffEditorGutter, reader), this.elements.root, this._diffModel, this._editors)
+                : undefined;
+        });
         this._register(recomputeInitiallyAndOnChange(this._layoutInfo));
         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);
@@ -159,20 +189,8 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
             visibility: derived(reader =>  (this._options.hideUnchangedRegions.read(reader) && this._diffModel.read(reader)?.diff.read(reader)?.mappings.length === 0)
                 ? 'visible' : 'hidden'),
         }));
-        this._register(Event.runAndSubscribe(this._editors.modified.onDidChangeCursorPosition, (e) => {
-            if (e?.reason === 3 ) {
-                const diff = this._diffModel.get()?.diff.get()?.mappings.find(m => m.lineRangeMapping.modified.contains(e.position.lineNumber));
-                if (diff?.lineRangeMapping.modified.isEmpty) {
-                    this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineDeleted, { source: 'diffEditor.cursorPositionChanged' });
-                }
-                else if (diff?.lineRangeMapping.original.isEmpty) {
-                    this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineInserted, { source: 'diffEditor.cursorPositionChanged' });
-                }
-                else if (diff) {
-                    this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineModified, { source: 'diffEditor.cursorPositionChanged' });
-                }
-            }
-        }));
+        this._register(Event.runAndSubscribe(this._editors.modified.onDidChangeCursorPosition, e => this._handleCursorPositionChange(e, true)));
+        this._register(Event.runAndSubscribe(this._editors.original.onDidChangeCursorPosition, e => this._handleCursorPositionChange(e, false)));
         const isInitializingDiff = ( this._diffModel.map(this, (m, reader) => {
             if (!m) {
                 return undefined;
@@ -190,7 +208,9 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
                 this._diffModel.get()?.dispose();
             }
         }));
-        this._register(( new RevertButtonsFeature(this._editors, this._diffModel, this._options, this)));
+        this._register(autorunWithStore((reader, store) => {
+            store.add(new (readHotReloadableExport(RevertButtonsFeature, reader))(this._editors, this._diffModel, this._options, this));
+        }));
     }
     getViewWidth() {
         return this._rootSizeObserver.width.get();
@@ -307,10 +327,6 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         };
     }
     revert(diff) {
-        if (diff.innerChanges) {
-            this.revertRangeMappings(diff.innerChanges);
-            return;
-        }
         const model = this._diffModel.get();
         if (!model || !model.isDiffUpToDate.get()) {
             return;
@@ -435,6 +451,20 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
             }
         });
     }
+    _handleCursorPositionChange(e, isModifiedEditor) {
+        if (e?.reason === 3 ) {
+            const diff = this._diffModel.get()?.diff.get()?.mappings.find(m => isModifiedEditor ? m.lineRangeMapping.modified.contains(e.position.lineNumber) : m.lineRangeMapping.original.contains(e.position.lineNumber));
+            if (diff?.lineRangeMapping.modified.isEmpty) {
+                this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineDeleted, { source: 'diffEditor.cursorPositionChanged' });
+            }
+            else if (diff?.lineRangeMapping.original.isEmpty) {
+                this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineInserted, { source: 'diffEditor.cursorPositionChanged' });
+            }
+            else if (diff) {
+                this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineModified, { source: 'diffEditor.cursorPositionChanged' });
+            }
+        }
+    }
 };
 DiffEditorWidget = ( __decorate([
     ( __param(3, IContextKeyService)),

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

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { mixin } from '../../../../base/common/objects.js';
+import { ICodeEditorService } from '../../services/codeEditorService.js';
+import { DiffEditorWidget } from './diffEditorWidget.js';
+import { IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IEditorProgressService } from '../../../../platform/progress/common/progress.js';
+let EmbeddedDiffEditorWidget = class EmbeddedDiffEditorWidget extends DiffEditorWidget {
+    constructor(domElement, options, codeEditorWidgetOptions, parentEditor, contextKeyService, instantiationService, codeEditorService, accessibilitySignalService, editorProgressService) {
+        super(domElement, parentEditor.getRawOptions(), codeEditorWidgetOptions, contextKeyService, instantiationService, codeEditorService, accessibilitySignalService, editorProgressService);
+        this._parentEditor = parentEditor;
+        this._overwriteOptions = options;
+        super.updateOptions(this._overwriteOptions);
+        this._register(parentEditor.onDidChangeConfiguration(e => this._onParentConfigurationChanged(e)));
+    }
+    getParentEditor() {
+        return this._parentEditor;
+    }
+    _onParentConfigurationChanged(e) {
+        super.updateOptions(this._parentEditor.getRawOptions());
+        super.updateOptions(this._overwriteOptions);
+    }
+    updateOptions(newOptions) {
+        mixin(this._overwriteOptions, newOptions, true);
+        super.updateOptions(this._overwriteOptions);
+    }
+};
+EmbeddedDiffEditorWidget = ( __decorate([
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ICodeEditorService)),
+    ( __param(7, IAccessibilitySignalService)),
+    ( __param(8, IEditorProgressService))
+], EmbeddedDiffEditorWidget));
+export { EmbeddedDiffEditorWidget };