@codingame/monaco-vscode-views-service-override 2.1.4 → 2.2.0-next.2

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/mergeEditor.js

@@ -1,612 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { reset } from 'vscode/vscode/vs/base/browser/dom';
-import { SerializableGrid } from '../../../../../base/browser/ui/grid/grid.js';
-import { Color } from 'vscode/vscode/vs/base/common/color';
-import { BugIndicatingError, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { DisposableStore, MutableDisposable, toDisposable, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isEqual, basename } from 'vscode/vscode/vs/base/common/resources';
-import { isDefined } from 'vscode/vscode/vs/base/common/types';
-import './media/mergeEditor.css.js';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { ITextResourceConfigurationService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { AbstractTextEditor } from 'vscode/vscode/vs/workbench/browser/parts/editor/textEditor';
-import { DEFAULT_EDITOR_ASSOCIATION } from 'vscode/vscode/vs/workbench/common/editor';
-import { applyTextEditorOptions } from 'vscode/vscode/vs/workbench/common/editor/editorOptions';
-import { readTransientState, writeTransientState } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/toggleWordWrap';
-import { MergeEditorInput } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput';
-import { observableConfigValue, PersistentStore, deepMerge, thenIfNotDisposed } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/browser/utils';
-import { BaseCodeEditorView } from './editors/baseCodeEditorView.js';
-import { ScrollSynchronizer } from './scrollSynchronizer.js';
-import { MergeEditorViewModel } from './viewModel.js';
-import { ViewZoneComputer } from './viewZones.js';
-import { ctxIsMergeEditor, ctxMergeEditorLayout, ctxMergeEditorShowBase, ctxMergeEditorShowBaseAtTop, ctxMergeResultUri, ctxMergeBaseUri, ctxMergeEditorShowNonConflictingChanges } from 'vscode/vscode/vs/workbench/contrib/mergeEditor/common/mergeEditor';
-import { settingsSashBorder } from 'vscode/vscode/vs/workbench/contrib/preferences/common/settingsEditorColorRegistry';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-import { RegisteredEditorPriority, IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { InputCodeEditorView } from './editors/inputCodeEditorView.js';
-import { ResultCodeEditorView } from './editors/resultCodeEditorView.js';
-import { observableValue, transaction } from 'vscode/vscode/vs/base/common/observableInternal/base';
-import { autorunWithStore, autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
-
-var MergeEditor_1, MergeEditorLayoutStore_1;
-let MergeEditor = class MergeEditor extends AbstractTextEditor {
-    static { MergeEditor_1 = this; }
-    static { this.ID = 'mergeEditor'; }
-    get viewModel() {
-        return this._viewModel;
-    }
-    get inputModel() {
-        return this._inputModel;
-    }
-    get model() {
-        return this.inputModel.get()?.model;
-    }
-    get inputsWritable() {
-        return !!this._configurationService.getValue('mergeEditor.writableInputs');
-    }
-    constructor(instantiation, contextKeyService, telemetryService, storageService, themeService, textResourceConfigurationService, _configurationService, editorService, editorGroupService, fileService, _codeEditorService, configurationService) {
-        super(MergeEditor_1.ID, telemetryService, instantiation, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService);
-        this.contextKeyService = contextKeyService;
-        this._configurationService = _configurationService;
-        this._codeEditorService = _codeEditorService;
-        this.configurationService = configurationService;
-        this._sessionDisposables = ( new DisposableStore());
-        this._viewModel = observableValue(this, undefined);
-        this._grid = this._register(( new MutableDisposable()));
-        this.input1View = this._register(this.instantiationService.createInstance(InputCodeEditorView, 1, this._viewModel));
-        this.baseView = observableValue(this, undefined);
-        this.baseViewOptions = observableValue(this, undefined);
-        this.input2View = this._register(this.instantiationService.createInstance(InputCodeEditorView, 2, this._viewModel));
-        this.inputResultView = this._register(this.instantiationService.createInstance(ResultCodeEditorView, this._viewModel));
-        this._layoutMode = this.instantiationService.createInstance(MergeEditorLayoutStore);
-        this._layoutModeObs = observableValue(this, this._layoutMode.value);
-        this._ctxIsMergeEditor = ctxIsMergeEditor.bindTo(this.contextKeyService);
-        this._ctxUsesColumnLayout = ctxMergeEditorLayout.bindTo(this.contextKeyService);
-        this._ctxShowBase = ctxMergeEditorShowBase.bindTo(this.contextKeyService);
-        this._ctxShowBaseAtTop = ctxMergeEditorShowBaseAtTop.bindTo(this.contextKeyService);
-        this._ctxResultUri = ctxMergeResultUri.bindTo(this.contextKeyService);
-        this._ctxBaseUri = ctxMergeBaseUri.bindTo(this.contextKeyService);
-        this._ctxShowNonConflictingChanges = ctxMergeEditorShowNonConflictingChanges.bindTo(this.contextKeyService);
-        this._inputModel = observableValue(this, undefined);
-        this.viewZoneComputer = ( new ViewZoneComputer(
-            this.input1View.editor,
-            this.input2View.editor,
-            this.inputResultView.editor
-        ));
-        this.codeLensesVisible = observableConfigValue('mergeEditor.showCodeLenses', true, this.configurationService);
-        this.scrollSynchronizer = this._register(( new ScrollSynchronizer(
-            this._viewModel,
-            this.input1View,
-            this.input2View,
-            this.baseView,
-            this.inputResultView,
-            this._layoutModeObs
-        )));
-        this._onDidChangeSizeConstraints = ( new Emitter());
-        this.onDidChangeSizeConstraints = this._onDidChangeSizeConstraints.event;
-        this.baseViewDisposables = this._register(( new DisposableStore()));
-        this.showNonConflictingChangesStore = this.instantiationService.createInstance((PersistentStore), 'mergeEditor/showNonConflictingChanges');
-        this.showNonConflictingChanges = observableValue(this, this.showNonConflictingChangesStore.get() ?? false);
-    }
-    dispose() {
-        this._sessionDisposables.dispose();
-        this._ctxIsMergeEditor.reset();
-        this._ctxUsesColumnLayout.reset();
-        this._ctxShowNonConflictingChanges.reset();
-        super.dispose();
-    }
-    get minimumWidth() {
-        return this._layoutMode.value.kind === 'mixed'
-            ? this.input1View.view.minimumWidth + this.input2View.view.minimumWidth
-            : this.input1View.view.minimumWidth + this.input2View.view.minimumWidth + this.inputResultView.view.minimumWidth;
-    }
-    getTitle() {
-        if (this.input) {
-            return this.input.getName();
-        }
-        return ( localizeWithPath(
-            'vs/workbench/contrib/mergeEditor/browser/view/mergeEditor',
-            'mergeEditor',
-            "Text Merge Editor"
-        ));
-    }
-    createEditorControl(parent, initialOptions) {
-        this.rootHtmlElement = parent;
-        parent.classList.add('merge-editor');
-        this.applyLayout(this._layoutMode.value);
-        this.applyOptions(initialOptions);
-    }
-    updateEditorControlOptions(options) {
-        this.applyOptions(options);
-    }
-    applyOptions(options) {
-        const inputOptions = deepMerge(options, {
-            minimap: { enabled: false },
-            glyphMargin: false,
-            lineNumbersMinChars: 2,
-            readOnly: !this.inputsWritable
-        });
-        this.input1View.updateOptions(inputOptions);
-        this.input2View.updateOptions(inputOptions);
-        this.baseViewOptions.set({ ...this.input2View.editor.getRawOptions() }, undefined);
-        this.inputResultView.updateOptions(options);
-    }
-    getMainControl() {
-        return this.inputResultView.editor;
-    }
-    layout(dimension) {
-        this._grid.value?.layout(dimension.width, dimension.height);
-    }
-    async setInput(input, options, context, token) {
-        if (!(input instanceof MergeEditorInput)) {
-            throw new BugIndicatingError('ONLY MergeEditorInput is supported');
-        }
-        await super.setInput(input, options, context, token);
-        this._sessionDisposables.clear();
-        transaction(tx => {
-            this._viewModel.set(undefined, tx);
-            this._inputModel.set(undefined, tx);
-        });
-        const inputModel = await input.resolve();
-        const model = inputModel.model;
-        const viewModel = this.instantiationService.createInstance(MergeEditorViewModel, model, this.input1View, this.input2View, this.inputResultView, this.baseView, this.showNonConflictingChanges);
-        model.telemetry.reportMergeEditorOpened({
-            combinableConflictCount: model.combinableConflictCount,
-            conflictCount: model.conflictCount,
-            baseTop: this._layoutModeObs.get().showBaseAtTop,
-            baseVisible: this._layoutModeObs.get().showBase,
-            isColumnView: this._layoutModeObs.get().kind === 'columns',
-        });
-        transaction(tx => {
-            this._viewModel.set(viewModel, tx);
-            this._inputModel.set(inputModel, tx);
-        });
-        this._sessionDisposables.add(viewModel);
-        this._ctxResultUri.set(( inputModel.resultUri.toString()));
-        this._ctxBaseUri.set(( model.base.uri.toString()));
-        this._sessionDisposables.add(toDisposable(() => {
-            this._ctxBaseUri.reset();
-            this._ctxResultUri.reset();
-        }));
-        this._sessionDisposables.add(autorunWithStore((reader, store) => {
-            const baseView = this.baseView.read(reader);
-            this.inputResultView.editor.changeViewZones(resultViewZoneAccessor => {
-                const layout = this._layoutModeObs.read(reader);
-                const shouldAlignResult = layout.kind === 'columns';
-                const shouldAlignBase = layout.kind === 'mixed' && !layout.showBaseAtTop;
-                this.input1View.editor.changeViewZones(input1ViewZoneAccessor => {
-                    this.input2View.editor.changeViewZones(input2ViewZoneAccessor => {
-                        if (baseView) {
-                            baseView.editor.changeViewZones(baseViewZoneAccessor => {
-                                store.add(this.setViewZones(reader, viewModel, this.input1View.editor, input1ViewZoneAccessor, this.input2View.editor, input2ViewZoneAccessor, baseView.editor, baseViewZoneAccessor, shouldAlignBase, this.inputResultView.editor, resultViewZoneAccessor, shouldAlignResult));
-                            });
-                        }
-                        else {
-                            store.add(this.setViewZones(reader, viewModel, this.input1View.editor, input1ViewZoneAccessor, this.input2View.editor, input2ViewZoneAccessor, undefined, undefined, false, this.inputResultView.editor, resultViewZoneAccessor, shouldAlignResult));
-                        }
-                    });
-                });
-            });
-            this.scrollSynchronizer.updateScrolling();
-        }));
-        const viewState = this.loadEditorViewState(input, context);
-        if (viewState) {
-            this._applyViewState(viewState);
-        }
-        else {
-            this._sessionDisposables.add(thenIfNotDisposed(model.onInitialized, () => {
-                const firstConflict = model.modifiedBaseRanges.get().find(r => r.isConflicting);
-                if (!firstConflict) {
-                    return;
-                }
-                this.input1View.editor.revealLineInCenter(firstConflict.input1Range.startLineNumber);
-                transaction(tx => {
-                    viewModel.setActiveModifiedBaseRange(firstConflict, tx);
-                });
-            }));
-        }
-        const mirrorWordWrapTransientState = (candidate) => {
-            const candidateState = readTransientState(candidate, this._codeEditorService);
-            writeTransientState(model.input2.textModel, candidateState, this._codeEditorService);
-            writeTransientState(model.input1.textModel, candidateState, this._codeEditorService);
-            writeTransientState(model.resultTextModel, candidateState, this._codeEditorService);
-            const baseTextModel = this.baseView.get()?.editor.getModel();
-            if (baseTextModel) {
-                writeTransientState(baseTextModel, candidateState, this._codeEditorService);
-            }
-        };
-        this._sessionDisposables.add(this._codeEditorService.onDidChangeTransientModelProperty(candidate => {
-            mirrorWordWrapTransientState(candidate);
-        }));
-        mirrorWordWrapTransientState(this.inputResultView.editor.getModel());
-        const that = this;
-        this._sessionDisposables.add(new (class {
-            constructor() {
-                this._disposable = ( new DisposableStore());
-                for (const model of this.baseInput1Input2()) {
-                    this._disposable.add(model.onDidChangeContent(() => this._checkBaseInput1Input2AllEmpty()));
-                }
-            }
-            dispose() {
-                this._disposable.dispose();
-            }
-            *baseInput1Input2() {
-                yield model.base;
-                yield model.input1.textModel;
-                yield model.input2.textModel;
-            }
-            _checkBaseInput1Input2AllEmpty() {
-                for (const model of this.baseInput1Input2()) {
-                    if (model.getValueLength() > 0) {
-                        return;
-                    }
-                }
-                that.editorService.replaceEditors([{ editor: input, replacement: { resource: input.result, options: { preserveFocus: true } }, forceReplaceDirty: true }], that.group ?? that.editorGroupService.activeGroup);
-            }
-        }));
-    }
-    setViewZones(reader, viewModel, input1Editor, input1ViewZoneAccessor, input2Editor, input2ViewZoneAccessor, baseEditor, baseViewZoneAccessor, shouldAlignBase, resultEditor, resultViewZoneAccessor, shouldAlignResult) {
-        const input1ViewZoneIds = [];
-        const input2ViewZoneIds = [];
-        const baseViewZoneIds = [];
-        const resultViewZoneIds = [];
-        const viewZones = this.viewZoneComputer.computeViewZones(reader, viewModel, {
-            codeLensesVisible: this.codeLensesVisible.read(reader),
-            showNonConflictingChanges: this.showNonConflictingChanges.read(reader),
-            shouldAlignBase,
-            shouldAlignResult,
-        });
-        const disposableStore = ( new DisposableStore());
-        if (baseViewZoneAccessor) {
-            for (const v of viewZones.baseViewZones) {
-                v.create(baseViewZoneAccessor, baseViewZoneIds, disposableStore);
-            }
-        }
-        for (const v of viewZones.resultViewZones) {
-            v.create(resultViewZoneAccessor, resultViewZoneIds, disposableStore);
-        }
-        for (const v of viewZones.input1ViewZones) {
-            v.create(input1ViewZoneAccessor, input1ViewZoneIds, disposableStore);
-        }
-        for (const v of viewZones.input2ViewZones) {
-            v.create(input2ViewZoneAccessor, input2ViewZoneIds, disposableStore);
-        }
-        disposableStore.add({
-            dispose: () => {
-                input1Editor.changeViewZones(a => {
-                    for (const zone of input1ViewZoneIds) {
-                        a.removeZone(zone);
-                    }
-                });
-                input2Editor.changeViewZones(a => {
-                    for (const zone of input2ViewZoneIds) {
-                        a.removeZone(zone);
-                    }
-                });
-                baseEditor?.changeViewZones(a => {
-                    for (const zone of baseViewZoneIds) {
-                        a.removeZone(zone);
-                    }
-                });
-                resultEditor.changeViewZones(a => {
-                    for (const zone of resultViewZoneIds) {
-                        a.removeZone(zone);
-                    }
-                });
-            }
-        });
-        return disposableStore;
-    }
-    setOptions(options) {
-        super.setOptions(options);
-        if (options) {
-            applyTextEditorOptions(options, this.inputResultView.editor, 0 );
-        }
-    }
-    clearInput() {
-        super.clearInput();
-        this._sessionDisposables.clear();
-        for (const { editor } of [this.input1View, this.input2View, this.inputResultView]) {
-            editor.setModel(null);
-        }
-    }
-    focus() {
-        super.focus();
-        (this.getControl() ?? this.inputResultView.editor).focus();
-    }
-    hasFocus() {
-        for (const { editor } of [this.input1View, this.input2View, this.inputResultView]) {
-            if (editor.hasTextFocus()) {
-                return true;
-            }
-        }
-        return super.hasFocus();
-    }
-    setEditorVisible(visible, group) {
-        super.setEditorVisible(visible, group);
-        for (const { editor } of [this.input1View, this.input2View, this.inputResultView]) {
-            if (visible) {
-                editor.onVisible();
-            }
-            else {
-                editor.onHide();
-            }
-        }
-        this._ctxIsMergeEditor.set(visible);
-    }
-    getControl() {
-        return this.inputResultView.editor;
-    }
-    get scopedContextKeyService() {
-        const control = this.getControl();
-        return control?.invokeWithinContext(accessor => accessor.get(IContextKeyService));
-    }
-    toggleBase() {
-        this.setLayout({
-            ...this._layoutMode.value,
-            showBase: !this._layoutMode.value.showBase
-        });
-    }
-    toggleShowBaseTop() {
-        const showBaseTop = this._layoutMode.value.showBase && this._layoutMode.value.showBaseAtTop;
-        this.setLayout({
-            ...this._layoutMode.value,
-            showBaseAtTop: true,
-            showBase: !showBaseTop,
-        });
-    }
-    toggleShowBaseCenter() {
-        const showBaseCenter = this._layoutMode.value.showBase && !this._layoutMode.value.showBaseAtTop;
-        this.setLayout({
-            ...this._layoutMode.value,
-            showBaseAtTop: false,
-            showBase: !showBaseCenter,
-        });
-    }
-    setLayoutKind(kind) {
-        this.setLayout({
-            ...this._layoutMode.value,
-            kind
-        });
-    }
-    setLayout(newLayout) {
-        const value = this._layoutMode.value;
-        if (JSON.stringify(value) === JSON.stringify(newLayout)) {
-            return;
-        }
-        this.model?.telemetry.reportLayoutChange({
-            baseTop: newLayout.showBaseAtTop,
-            baseVisible: newLayout.showBase,
-            isColumnView: newLayout.kind === 'columns',
-        });
-        this.applyLayout(newLayout);
-    }
-    applyLayout(layout) {
-        transaction(tx => {
-            if (layout.showBase && !this.baseView.get()) {
-                this.baseViewDisposables.clear();
-                const baseView = this.baseViewDisposables.add(this.instantiationService.createInstance(BaseCodeEditorView, this.viewModel));
-                this.baseViewDisposables.add(autorun(reader => {
-                    const options = this.baseViewOptions.read(reader);
-                    if (options) {
-                        baseView.updateOptions(options);
-                    }
-                }));
-                this.baseView.set(baseView, tx);
-            }
-            else if (!layout.showBase && this.baseView.get()) {
-                this.baseView.set(undefined, tx);
-                this.baseViewDisposables.clear();
-            }
-            if (layout.kind === 'mixed') {
-                this.setGrid([
-                    layout.showBaseAtTop && layout.showBase ? {
-                        size: 38,
-                        data: this.baseView.get().view
-                    } : undefined,
-                    {
-                        size: 38,
-                        groups: [
-                            { data: this.input1View.view },
-                            !layout.showBaseAtTop && layout.showBase ? { data: this.baseView.get().view } : undefined,
-                            { data: this.input2View.view }
-                        ].filter(isDefined)
-                    },
-                    {
-                        size: 62,
-                        data: this.inputResultView.view
-                    },
-                ].filter(isDefined));
-            }
-            else if (layout.kind === 'columns') {
-                this.setGrid([
-                    layout.showBase ? {
-                        size: 40,
-                        data: this.baseView.get().view
-                    } : undefined,
-                    {
-                        size: 60,
-                        groups: [{ data: this.input1View.view }, { data: this.inputResultView.view }, { data: this.input2View.view }]
-                    },
-                ].filter(isDefined));
-            }
-            this._layoutMode.value = layout;
-            this._ctxUsesColumnLayout.set(layout.kind);
-            this._ctxShowBase.set(layout.showBase);
-            this._ctxShowBaseAtTop.set(layout.showBaseAtTop);
-            this._onDidChangeSizeConstraints.fire();
-            this._layoutModeObs.set(layout, tx);
-        });
-    }
-    setGrid(descriptor) {
-        let width = -1;
-        let height = -1;
-        if (this._grid.value) {
-            width = this._grid.value.width;
-            height = this._grid.value.height;
-        }
-        this._grid.value = SerializableGrid.from({
-            orientation: 0 ,
-            size: 100,
-            groups: descriptor,
-        }, {
-            styles: { separatorBorder: this.theme.getColor(settingsSashBorder) ?? Color.transparent },
-            proportionalLayout: true
-        });
-        reset(this.rootHtmlElement, this._grid.value.element);
-        if (width !== -1) {
-            this._grid.value.layout(width, height);
-        }
-    }
-    _applyViewState(state) {
-        if (!state) {
-            return;
-        }
-        this.inputResultView.editor.restoreViewState(state);
-        if (state.input1State) {
-            this.input1View.editor.restoreViewState(state.input1State);
-        }
-        if (state.input2State) {
-            this.input2View.editor.restoreViewState(state.input2State);
-        }
-        if (state.focusIndex >= 0) {
-            [this.input1View.editor, this.input2View.editor, this.inputResultView.editor][state.focusIndex].focus();
-        }
-    }
-    computeEditorViewState(resource) {
-        if (!isEqual(this.inputModel.get()?.resultUri, resource)) {
-            return undefined;
-        }
-        const result = this.inputResultView.editor.saveViewState();
-        if (!result) {
-            return undefined;
-        }
-        const input1State = this.input1View.editor.saveViewState() ?? undefined;
-        const input2State = this.input2View.editor.saveViewState() ?? undefined;
-        const focusIndex = [this.input1View.editor, this.input2View.editor, this.inputResultView.editor].findIndex(editor => editor.hasWidgetFocus());
-        return { ...result, input1State, input2State, focusIndex };
-    }
-    tracksEditorViewState(input) {
-        return input instanceof MergeEditorInput;
-    }
-    toggleShowNonConflictingChanges() {
-        this.showNonConflictingChanges.set(!this.showNonConflictingChanges.get(), undefined);
-        this.showNonConflictingChangesStore.set(this.showNonConflictingChanges.get());
-        this._ctxShowNonConflictingChanges.set(this.showNonConflictingChanges.get());
-    }
-};
-MergeEditor = MergeEditor_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, ITextResourceConfigurationService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IEditorGroupsService)),
-    ( __param(9, IFileService)),
-    ( __param(10, ICodeEditorService)),
-    ( __param(11, IConfigurationService))
-], MergeEditor));
-let MergeEditorLayoutStore = class MergeEditorLayoutStore {
-    static { MergeEditorLayoutStore_1 = this; }
-    static { this._key = 'mergeEditor/layout'; }
-    constructor(_storageService) {
-        this._storageService = _storageService;
-        this._value = { kind: 'mixed', showBase: false, showBaseAtTop: true };
-        const value = _storageService.get(MergeEditorLayoutStore_1._key, 0 , 'mixed');
-        if (value === 'mixed' || value === 'columns') {
-            this._value = { kind: value, showBase: false, showBaseAtTop: true };
-        }
-        else if (value) {
-            try {
-                this._value = JSON.parse(value);
-            }
-            catch (e) {
-                onUnexpectedError(e);
-            }
-        }
-    }
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        if (this._value !== value) {
-            this._value = value;
-            this._storageService.store(MergeEditorLayoutStore_1._key, JSON.stringify(this._value), 0 , 0 );
-        }
-    }
-};
-MergeEditorLayoutStore = MergeEditorLayoutStore_1 = ( __decorate([
-    ( __param(0, IStorageService))
-], MergeEditorLayoutStore));
-let MergeEditorOpenHandlerContribution = class MergeEditorOpenHandlerContribution extends Disposable {
-    constructor(_editorService, codeEditorService) {
-        super();
-        this._editorService = _editorService;
-        this._store.add(codeEditorService.registerCodeEditorOpenHandler(this.openCodeEditorFromMergeEditor.bind(this)));
-    }
-    async openCodeEditorFromMergeEditor(input, _source, sideBySide) {
-        const activePane = this._editorService.activeEditorPane;
-        if (!sideBySide
-            && input.options
-            && activePane instanceof MergeEditor
-            && activePane.getControl()
-            && activePane.input instanceof MergeEditorInput
-            && isEqual(input.resource, activePane.input.result)) {
-            const targetEditor = activePane.getControl();
-            applyTextEditorOptions(input.options, targetEditor, 0 );
-            return targetEditor;
-        }
-        return null;
-    }
-};
-MergeEditorOpenHandlerContribution = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, ICodeEditorService))
-], MergeEditorOpenHandlerContribution));
-let MergeEditorResolverContribution = class MergeEditorResolverContribution extends Disposable {
-    constructor(editorResolverService, instantiationService) {
-        super();
-        const mergeEditorInputFactory = (mergeEditor) => {
-            return {
-                editor: instantiationService.createInstance(MergeEditorInput, mergeEditor.base.resource, {
-                    uri: mergeEditor.input1.resource,
-                    title: mergeEditor.input1.label ?? basename(mergeEditor.input1.resource),
-                    description: mergeEditor.input1.description ?? '',
-                    detail: mergeEditor.input1.detail
-                }, {
-                    uri: mergeEditor.input2.resource,
-                    title: mergeEditor.input2.label ?? basename(mergeEditor.input2.resource),
-                    description: mergeEditor.input2.description ?? '',
-                    detail: mergeEditor.input2.detail
-                }, mergeEditor.result.resource)
-            };
-        };
-        this._register(editorResolverService.registerEditor(`*`, {
-            id: DEFAULT_EDITOR_ASSOCIATION.id,
-            label: DEFAULT_EDITOR_ASSOCIATION.displayName,
-            detail: DEFAULT_EDITOR_ASSOCIATION.providerDisplayName,
-            priority: RegisteredEditorPriority.builtin
-        }, {}, {
-            createMergeEditorInput: mergeEditorInputFactory
-        }));
-    }
-};
-MergeEditorResolverContribution = ( __decorate([
-    ( __param(0, IEditorResolverService)),
-    ( __param(1, IInstantiationService))
-], MergeEditorResolverContribution));
-
-export { MergeEditor, MergeEditorOpenHandlerContribution, MergeEditorResolverContribution };