@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorLogging.d.ts

@@ -0,0 +1,60 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { URI } from "../../../../base/common/uri.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { MultiDiffEditorViewModel } from "./multiDiffEditorViewModel.js";
+/** A diff item of the multi diff editor, as far as logging is concerned. */
+export interface ILoggedDiffItem {
+    getKey(): string;
+    /** Short, log friendly name of the item. */
+    getLabel(): string;
+    readonly collapsed: IObservable<boolean>;
+    readonly contentHeight: IObservable<number>;
+}
+/** The widget state traced by {@link MultiDiffEditorLogger.logStateChanges}. */
+export interface ILoggedEditorState {
+    readonly viewModel: IObservable<MultiDiffEditorViewModel | undefined>;
+    readonly items: IObservable<readonly ILoggedDiffItem[]>;
+    readonly spaceBetweenPx: number;
+    readonly getScrollTop: () => number;
+    readonly isPreserveFocusOnLoad: () => boolean;
+}
+/**
+ * Trace logger for the multi diff editor. Logs the state transitions that are
+ * hard to observe from the outside (scroll offsets that are set programmatically,
+ * content height changes, collapsed state changes and view state save/restore),
+ * so bugs like "the editor jumped while scrolling" or "this file was expanded
+ * even though it was collapsed" can be reconstructed from the log.
+ *
+ * Enable with `Developer: Set Log Level...` > `Window` > `Trace`.
+ */
+export declare class MultiDiffEditorLogger extends Disposable {
+    private readonly _logService;
+    /** Last logged collapsed state per diff item, to only log actual changes. */
+    private readonly _lastLoggedCollapsed;
+    /** Last logged content height per diff item, to only log actual changes. */
+    private readonly _lastLoggedContentHeight;
+    private readonly _isEnabled;
+    constructor(_logService: ILogService);
+    /**
+     * Whether trace logging is on. Check this before computing data that is only
+     * needed for logging.
+     */
+    get isEnabled(): boolean;
+    log(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Traces the state transitions that cannot be reconstructed after the fact:
+     * view model/loading changes, collapsed state changes (no matter who caused
+     * them) and content height changes, which are the usual cause of the view
+     * jumping while scrolling. Per-frame rendering is deliberately not traced.
+     *
+     * The observers only exist while trace logging is on, so nothing is observed
+     * (and no state is tracked) in the default case; they are recreated when the
+     * log level is raised to trace again.
+     */
+    logStateChanges(state: ILoggedEditorState): void;
+}
+/** Short, log friendly name of a diff item resource. */
+export declare function formatUri(uri: URI | undefined): string;
+/** Turns a {@link DocumentDiffItemViewModel.getKey} value into a short log label. */
+export declare function formatDiffItemKey(key: string | undefined): string;

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorLogging.js

@@ -0,0 +1,132 @@
+
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
+import { basename } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import { LogLevel } from '../../../../platform/log/common/log.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { autorunWithStore, autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
+
+class MultiDiffEditorLogger extends Disposable {
+    constructor(_logService) {
+        super();
+        this._logService = _logService;
+        this._lastLoggedCollapsed = ( new Map());
+        this._lastLoggedContentHeight = ( new Map());
+        this._isEnabled = observableFromEvent(
+            this,
+            this._logService.onDidChangeLogLevel,
+            () => this._logService.getLevel() <= LogLevel.Trace
+        );
+    }
+    get isEnabled() {
+        return this._isEnabled.get();
+    }
+    log(message, data) {
+        if (!this.isEnabled) {
+            return;
+        }
+        const formattedData = data ? ( Object.entries(data).map(([key, value]) => `${key}: ${formatValue(value)}`)).join(", ") : undefined;
+        this._logService.trace(
+            `[MultiDiffEditor] ${message}${formattedData ? ` (${formattedData})` : ""}`
+        );
+    }
+    logStateChanges(state) {
+        this._register(autorunWithStore((reader, store) => {
+            if (!this._isEnabled.read(reader)) {
+                return;
+            }
+            store.add(toDisposable(() => {
+                this._lastLoggedCollapsed.clear();
+                this._lastLoggedContentHeight.clear();
+            }));
+            store.add(autorun(reader => {
+                const viewModel = state.viewModel.read(reader);
+                this.log("view model changed", {
+                    hasViewModel: !!viewModel,
+                    isLoading: viewModel?.isLoading.read(reader),
+                    preserveFocusOnLoad: state.isPreserveFocusOnLoad()
+                });
+            }));
+            store.add(autorun(reader => {
+                const changed = [];
+                for (const item of state.items.read(reader)) {
+                    const collapsed = item.collapsed.read(reader);
+                    const key = item.getKey();
+                    if (this._lastLoggedCollapsed.get(key) !== collapsed) {
+                        this._lastLoggedCollapsed.set(key, collapsed);
+                        changed.push(`${item.getLabel()}=${collapsed}`);
+                    }
+                }
+                if (changed.length > 0) {
+                    this.log("collapsed state changed", {
+                        changed
+                    });
+                }
+            }));
+            store.add(autorun(reader => {
+                const scrollTop = state.getScrollTop();
+                const changed = [];
+                let totalHeight = 0;
+                for (const item of state.items.read(reader)) {
+                    const contentHeight = item.contentHeight.read(reader);
+                    const key = item.getKey();
+                    const lastContentHeight = this._lastLoggedContentHeight.get(key);
+                    if (lastContentHeight !== contentHeight) {
+                        const abovePosition = totalHeight < scrollTop ? " (above scroll offset)" : "";
+                        changed.push(
+                            `${item.getLabel()}: ${lastContentHeight ?? "?"} -> ${contentHeight}${abovePosition}`
+                        );
+                        this._lastLoggedContentHeight.set(key, contentHeight);
+                    }
+                    totalHeight += contentHeight + state.spaceBetweenPx;
+                }
+                if (changed.length > 0) {
+                    this.log("content height changed", {
+                        changed,
+                        totalHeight,
+                        scrollTop
+                    });
+                }
+            }));
+        }));
+    }
+}
+function formatUri(uri) {
+    if (!uri) {
+        return "<none>";
+    }
+    return basename(uri) || uri.authority || uri.scheme;
+}
+function formatDiffItemKey(key) {
+    if (key === undefined) {
+        return "<none>";
+    }
+    try {
+        const [original, modified] = JSON.parse(key);
+        const uri = modified ?? original;
+        return uri ? formatUri(( URI.parse(uri))) : "<none>";
+    } catch {
+        return key;
+    }
+}
+function formatValue(value) {
+    if (value === undefined) {
+        return "<undefined>";
+    }
+    if (URI.isUri(value)) {
+        return formatUri(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${( value.map(formatValue)).join(", ")}]`;
+    }
+    if (typeof value === "number") {
+        return String(Math.round(value * 100) / 100);
+    }
+    if (typeof value === "object") {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+
+export { MultiDiffEditorLogger, formatDiffItemKey, formatUri };

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorOptions.d.ts

@@ -0,0 +1,20 @@
+import { IDiffEditorOptions } from "../../../common/config/editorOptions.js";
+export declare enum MultiDiffEditorVariant {
+    Standard = "standard",
+    Compact = "compact"
+}
+export interface IMultiDiffEditorWidgetOptions {
+    readonly variant: MultiDiffEditorVariant;
+    readonly diffEditorOptions?: IDiffEditorOptions;
+}
+export interface IMultiDiffEditorVariantConfiguration {
+    readonly className: string;
+    readonly horizontalInsets: Readonly<{
+        left: number;
+        right: number;
+    }>;
+    readonly headerHeight: number;
+    readonly contentBottomPadding: number;
+    readonly headerClickToCollapse: boolean;
+}
+export declare function getMultiDiffEditorVariantConfiguration(variant: MultiDiffEditorVariant): IMultiDiffEditorVariantConfiguration;

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorOptions.js

@@ -0,0 +1,29 @@
+
+
+var MultiDiffEditorVariant;
+(function (MultiDiffEditorVariant) {
+    MultiDiffEditorVariant["Standard"] = "standard";
+    MultiDiffEditorVariant["Compact"] = "compact";
+})(MultiDiffEditorVariant || (MultiDiffEditorVariant = {}));
+function getMultiDiffEditorVariantConfiguration(variant) {
+    switch (variant) {
+        case MultiDiffEditorVariant.Standard:
+            return {
+                className: 'multiDiffEditor-standard',
+                horizontalInsets: { left: 9, right: 9 },
+                headerHeight: 40,
+                contentBottomPadding: 0,
+                headerClickToCollapse: false,
+            };
+        case MultiDiffEditorVariant.Compact:
+            return {
+                className: 'multiDiffEditor-compact',
+                horizontalInsets: { left: 0, right: 0 },
+                headerHeight: 32,
+                contentBottomPadding: 8,
+                headerClickToCollapse: true,
+            };
+    }
+}
+
+export { MultiDiffEditorVariant, getMultiDiffEditorVariantConfiguration };

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorViewModel.d.ts

@@ -4,8 +4,8 @@ import { URI } from "../../../../base/common/uri.js";
 import { ContextKeyValue } from "../../../../platform/contextkey/common/contextkey.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
 import { Selection } from "../../../common/core/selection.js";
-import { IDiffEditorViewModel } from "../../../common/editorCommon.js";
 import { IModelService } from "../../../common/services/model.service.js";
+import { DiffEditorViewModel } from "../diffEditor/diffEditorViewModel.js";
 import { RefCounted } from "../diffEditor/utils.js";
 import { IDocumentDiffItem, IMultiDiffEditorModel } from "./model.js";
 export declare class MultiDiffEditorViewModel extends Disposable {
@@ -36,17 +36,20 @@ export declare class DocumentDiffItemViewModel extends Disposable {
     /**
      * The diff editor view model keeps its inner objects alive.
     */
-    readonly diffEditorViewModelRef: RefCounted<IDiffEditorViewModel>;
-    get diffEditorViewModel(): IDiffEditorViewModel;
+    readonly diffEditorViewModelRef: RefCounted<DiffEditorViewModel>;
+    get diffEditorViewModel(): DiffEditorViewModel;
     readonly waitForInitialDiffOr1s: ObservablePromise<void>;
     readonly collapsed: import("../../../../base/common/observable.js").ISettableObservable<boolean, void>;
     readonly lastTemplateData: import("../../../../base/common/observable.js").ISettableObservable<{
-        contentHeight: number;
+        expandedContentHeight: number;
         selections: Selection[] | undefined;
     }, void>;
     get originalUri(): URI | undefined;
     get modifiedUri(): URI | undefined;
+    get isBinary(): boolean;
     readonly isActive: IObservable<boolean>;
+    readonly isFirst: IObservable<boolean>;
+    setActive(tx: ITransaction | undefined): void;
     private readonly _isFocusedSource;
     readonly isFocused: import("../../../../base/common/observable.js").IObservableWithChange<boolean, void>;
     setIsFocused(source: IObservable<boolean>, tx: ITransaction | undefined): void;

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorViewModel.js

@@ -69,7 +69,7 @@ class MultiDiffEditorViewModel extends Disposable {
         );
         this.activeDiffItem = derivedObservableWithWritableCache(
             this,
-            (reader, lastValue) => this.focusedDiffItem.read(reader) ?? (lastValue && this.items.read(reader).indexOf(lastValue) !== -1) ? lastValue : undefined
+            (reader, lastValue) => this.focusedDiffItem.read(reader) ?? (lastValue && this.items.read(reader).indexOf(lastValue) !== -1 ? lastValue : undefined)
         );
         this._documents = observableFromValueWithChangeEvent(this.model, this.model.documents);
         const allItems = mapObservableArrayCached(this, this._documentsArr, (d, store) => store.add(RefCounted.create(
@@ -107,6 +107,16 @@ let DocumentDiffItemViewModel = class DocumentDiffItemViewModel extends Disposab
     get modifiedUri() {
         return this.documentDiffItem.modified?.uri;
     }
+    get isBinary() {
+        const {
+            original,
+            modified
+        } = this.documentDiffItem;
+        return (original !== undefined && original.textModel === undefined) || (modified !== undefined && modified.textModel === undefined);
+    }
+    setActive(tx) {
+        this._editorViewModel.activeDiffItem.setCache(this, tx);
+    }
     setIsFocused(source, tx) {
         this._isFocusedSource.set(source, tx);
     }
@@ -120,10 +130,11 @@ let DocumentDiffItemViewModel = class DocumentDiffItemViewModel extends Disposab
         this._modelService = _modelService;
         this.collapsed = observableValue(this, false);
         this.lastTemplateData = observableValue(this, {
-            contentHeight: 500,
+            expandedContentHeight: 500,
             selections: undefined
         });
         this.isActive = derived(this, reader => this._editorViewModel.activeDiffItem.read(reader) === this);
+        this.isFirst = derived(this, reader => this._editorViewModel.items.read(reader)[0] === this);
         this._isFocusedSource = observableValue(this, constObservable(false));
         this.isFocused = derived(this, reader => this._isFocusedSource.read(reader).read(reader));
         this.isAlive = observableValue(this, true);
@@ -146,8 +157,8 @@ let DocumentDiffItemViewModel = class DocumentDiffItemViewModel extends Disposab
             }));
         }
         const diffEditorViewModelStore = ( new DisposableStore());
-        const originalTextModel = this.documentDiffItem.original ?? diffEditorViewModelStore.add(this._modelService.createModel("", null));
-        const modifiedTextModel = this.documentDiffItem.modified ?? diffEditorViewModelStore.add(this._modelService.createModel("", null));
+        const originalTextModel = this.documentDiffItem.original?.textModel ?? diffEditorViewModelStore.add(this._modelService.createModel("", null));
+        const modifiedTextModel = this.documentDiffItem.modified?.textModel ?? diffEditorViewModelStore.add(this._modelService.createModel("", null));
         diffEditorViewModelStore.add(this._documentDiffItemRef.createNewRef(this));
         this.diffEditorViewModelRef = this._register(
             RefCounted.createWithDisposable(this._instantiationService.createInstance(DiffEditorViewModel, {

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget.d.ts

@@ -1,35 +1,62 @@
 import { Dimension } from "../../../../base/browser/dom.js";
 import { Event } from "../../../../base/common/event.js";
 import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
 import { Range } from "../../../common/core/range.js";
+import { DiffEditorViewMode } from "../../../common/config/editorOptions.js";
 import { IDiffEditor } from "../../../common/editorCommon.js";
+import { IMultiDiffResourceId } from "../../../common/multiDiffEditor.js";
 import { ICodeEditor } from "../../editorBrowser.js";
 import { DiffEditorWidget } from "../diffEditor/diffEditorWidget.js";
 import { IDocumentDiffItem, IMultiDiffEditorModel } from "./model.js";
+import { IMultiDiffEditorWidgetOptions } from "./multiDiffEditorOptions.js";
 import { MultiDiffEditorViewModel } from "./multiDiffEditorViewModel.js";
-import { IMultiDiffEditorViewState, IMultiDiffResourceId } from "./multiDiffEditorWidgetImpl.js";
+import { IMultiDiffEditorLayoutDebugState, IMultiDiffEditorViewState } from "./multiDiffEditorWidgetImpl.js";
 import { IWorkbenchUIElementFactory } from "./workbenchUIElementFactory.js";
 export declare class MultiDiffEditorWidget extends Disposable {
     private readonly _element;
     private readonly _workbenchUIElementFactory;
+    private readonly _options;
     private readonly _instantiationService;
     private readonly _dimension;
     private readonly _viewModel;
+    private readonly _diffLayoutOptions;
+    private readonly _paddingBottomPx;
+    private readonly _variantConfiguration;
     private readonly _widgetImpl;
-    constructor(_element: HTMLElement, _workbenchUIElementFactory: IWorkbenchUIElementFactory, _instantiationService: IInstantiationService);
+    constructor(_element: HTMLElement, _workbenchUIElementFactory: IWorkbenchUIElementFactory, _options: IMultiDiffEditorWidgetOptions, _instantiationService: IInstantiationService);
     reveal(resource: IMultiDiffResourceId, options?: RevealOptions): void;
     createViewModel(model: IMultiDiffEditorModel): MultiDiffEditorViewModel;
     setViewModel(viewModel: MultiDiffEditorViewModel | undefined, options?: {
         readonly preserveFocus?: boolean;
+        readonly viewState?: IMultiDiffEditorViewState;
     }): void;
     layout(dimension: Dimension): void;
+    /**
+     * Overrides whether the embedded diffs render side by side (`true`) or inline
+     * (`false`) as editor-local state, independent of the
+     * `diffEditor.renderSideBySide` setting. Responsive inline fallback is disabled
+     * unless explicitly enabled.
+     */
+    setRenderSideBySide(renderSideBySide: boolean, options?: {
+        readonly useInlineViewWhenSpaceIsLimited?: boolean;
+    }): void;
+    setViewMode(mode: DiffEditorViewMode): void;
+    setDiffLayoutOptions(mode: DiffEditorViewMode, diffWordWrap?: "off" | "on" | "inherit"): void;
+    toggleRenderSideBySide(): void;
+    setDiffWordWrap(diffWordWrap: "off" | "on" | "inherit"): void;
+    private _updateDiffLayoutOptions;
+    /** Reserves empty space below the last diff entry. */
+    setPaddingBottom(px: number): void;
     private readonly _activeControl;
     getActiveControl(): DiffEditorWidget | undefined;
     readonly onDidChangeActiveControl: Event<void>;
+    focus(): boolean;
     getViewState(): IMultiDiffEditorViewState;
+    getLayoutDebugState(): IObservable<IMultiDiffEditorLayoutDebugState>;
     setViewState(viewState: IMultiDiffEditorViewState): void;
     tryGetCodeEditor(resource: URI): {
         diffEditor: IDiffEditor;
@@ -38,6 +65,7 @@ export declare class MultiDiffEditorWidget extends Disposable {
     getRootElement(): HTMLElement;
     getContextKeyService(): IContextKeyService;
     getScopedInstantiationService(): IInstantiationService;
+    resetWidthBasedLayout(): void;
     findDocumentDiffItem(resource: URI): IDocumentDiffItem | undefined;
     goToNextChange(): void;
     goToPreviousChange(): void;

package/vscode/src/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget.js

@@ -7,31 +7,41 @@ import '../../../../base/common/observableInternal/index.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import './colors.js';
 import './diffEditorItemTemplate.js';
+import { getMultiDiffEditorVariantConfiguration } from './multiDiffEditorOptions.js';
 import { MultiDiffEditorViewModel } from './multiDiffEditorViewModel.js';
 import { MultiDiffEditorWidgetImpl } from './multiDiffEditorWidgetImpl.js';
 import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
 import { recomputeInitiallyAndOnChange } from '../../../../base/common/observableInternal/utils/utils.js';
+import { transaction } from '../../../../base/common/observableInternal/transaction.js';
 
 let MultiDiffEditorWidget = class MultiDiffEditorWidget extends Disposable {
-    constructor(_element, _workbenchUIElementFactory, _instantiationService) {
+    constructor(_element, _workbenchUIElementFactory, _options, _instantiationService) {
         super();
         this._element = _element;
         this._workbenchUIElementFactory = _workbenchUIElementFactory;
+        this._options = _options;
         this._instantiationService = _instantiationService;
         this._dimension = observableValue(this, undefined);
         this._viewModel = observableValue(this, undefined);
+        this._diffLayoutOptions = observableValue(this, undefined);
+        this._paddingBottomPx = observableValue(this, 0);
+        this._activeControl = derived(this, reader => this._widgetImpl.read(reader).activeControl.read(reader));
+        this.onDidChangeActiveControl = Event.fromObservableLight(this._activeControl);
+        this._variantConfiguration = getMultiDiffEditorVariantConfiguration(this._options.variant);
         this._widgetImpl = derived(this, reader => {
             return reader.store.add(this._instantiationService.createInstance(
                 (readHotReloadableExport(MultiDiffEditorWidgetImpl)),
                 this._element,
                 this._dimension,
                 this._viewModel,
-                this._workbenchUIElementFactory
+                this._workbenchUIElementFactory,
+                this._variantConfiguration,
+                this._diffLayoutOptions,
+                this._options.diffEditorOptions,
+                this._paddingBottomPx
             ));
         });
-        this._activeControl = derived(this, reader => this._widgetImpl.read(reader).activeControl.read(reader));
-        this.onDidChangeActiveControl = Event.fromObservableLight(this._activeControl);
         this._register(recomputeInitiallyAndOnChange(this._widgetImpl));
     }
     reveal(resource, options) {
@@ -41,18 +51,79 @@ let MultiDiffEditorWidget = class MultiDiffEditorWidget extends Disposable {
         return ( new MultiDiffEditorViewModel(model, this._instantiationService));
     }
     setViewModel(viewModel, options) {
+        if (this._store.isDisposed) {
+            return;
+        }
         this._widgetImpl.get().setPreserveFocusOnLoad(!!options?.preserveFocus);
-        this._viewModel.set(viewModel, undefined);
+        transaction(tx => {
+            this._viewModel.set(viewModel, tx);
+            if (options?.viewState) {
+                this._widgetImpl.get().setViewState(options.viewState, tx);
+            } else {
+                this._widgetImpl.get().clearPendingRestorationState();
+            }
+        });
     }
     layout(dimension) {
         this._dimension.set(dimension, undefined);
     }
+    setRenderSideBySide(renderSideBySide, options) {
+        this._updateDiffLayoutOptions({
+            renderSideBySide,
+            useInlineViewWhenSpaceIsLimited: options?.useInlineViewWhenSpaceIsLimited ?? false
+        });
+    }
+    setViewMode(mode) {
+        this.setDiffLayoutOptions(mode);
+    }
+    setDiffLayoutOptions(mode, diffWordWrap) {
+        const currentOptions = this._diffLayoutOptions.get();
+        const wasAutomatic = currentOptions?.renderSideBySide === true && currentOptions.useInlineViewWhenSpaceIsLimited === true;
+        this._updateDiffLayoutOptions({
+            renderSideBySide: mode !== "inline",
+            useInlineViewWhenSpaceIsLimited: mode === "automatic",
+            ...(diffWordWrap ? {
+                diffWordWrap
+            } : {})
+        });
+        if (mode === "automatic" && !wasAutomatic) {
+            this.resetWidthBasedLayout();
+        }
+    }
+    toggleRenderSideBySide() {
+        this.setRenderSideBySide(!(this._diffLayoutOptions.get()?.renderSideBySide ?? true));
+    }
+    setDiffWordWrap(diffWordWrap) {
+        this._updateDiffLayoutOptions({
+            diffWordWrap
+        });
+    }
+    _updateDiffLayoutOptions(options) {
+        const currentOptions = this._diffLayoutOptions.get();
+        const updatedOptions = {
+            ...currentOptions,
+            ...options
+        };
+        if (currentOptions?.renderSideBySide === updatedOptions.renderSideBySide && currentOptions?.useInlineViewWhenSpaceIsLimited === updatedOptions.useInlineViewWhenSpaceIsLimited && currentOptions?.diffWordWrap === updatedOptions.diffWordWrap) {
+            return;
+        }
+        this._diffLayoutOptions.set(updatedOptions, undefined);
+    }
+    setPaddingBottom(px) {
+        this._paddingBottomPx.set(px, undefined);
+    }
     getActiveControl() {
         return this._activeControl.get();
     }
+    focus() {
+        return this._widgetImpl.get().focus();
+    }
     getViewState() {
         return this._widgetImpl.get().getViewState();
     }
+    getLayoutDebugState() {
+        return this._widgetImpl.get().layoutDebugState;
+    }
     setViewState(viewState) {
         this._widgetImpl.get().setViewState(viewState);
     }
@@ -68,6 +139,9 @@ let MultiDiffEditorWidget = class MultiDiffEditorWidget extends Disposable {
     getScopedInstantiationService() {
         return this._widgetImpl.get().getScopedInstantiationService();
     }
+    resetWidthBasedLayout() {
+        this._widgetImpl.get().resetWidthBasedLayout();
+    }
     findDocumentDiffItem(resource) {
         return this._widgetImpl.get().findDocumentDiffItem(resource);
     }
@@ -78,6 +152,6 @@ let MultiDiffEditorWidget = class MultiDiffEditorWidget extends Disposable {
         this._widgetImpl.get().goToPreviousChange();
     }
 };
-MultiDiffEditorWidget = ( __decorate([( __param(2, IInstantiationService))], MultiDiffEditorWidget));
+MultiDiffEditorWidget = ( __decorate([( __param(3, IInstantiationService))], MultiDiffEditorWidget));
 
 export { MultiDiffEditorWidget };