@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.2

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

@@ -0,0 +1,346 @@
+import { createStyleSheet, isInShadowDOM, h, $, reset } from '../../../../../base/browser/dom.js';
+import { renderLabelWithIcons } from '../../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { hash } from '../../../../../base/common/hash.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { EDITOR_FONT_DEFAULTS } from '../../../../../editor/common/config/editorOptions.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { ModifiedBaseRangeStateKind, ModifiedBaseRangeState } from '../model/modifiedBaseRange.js';
+import { FixedZoneWidget } from './fixedZoneWidget.js';
+import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
+import { derived } from '../../../../../base/common/observableInternal/derived.js';
+import { transaction } from '../../../../../base/common/observableInternal/base.js';
+class ConflictActionsFactory extends Disposable {
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
+        this._register(this._editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(50 ) || e.hasChanged(19 ) || e.hasChanged(18 )) {
+                this._updateLensStyle();
+            }
+        }));
+        this._styleClassName = '_conflictActionsFactory_' + ( hash(this._editor.getId()).toString(16));
+        this._styleElement = createStyleSheet(isInShadowDOM(this._editor.getContainerDomNode())
+            ? this._editor.getContainerDomNode()
+            : undefined, undefined, this._store);
+        this._updateLensStyle();
+    }
+    _updateLensStyle() {
+        const { codeLensHeight, fontSize } = this._getLayoutInfo();
+        const fontFamily = this._editor.getOption(18 );
+        const editorFontInfo = this._editor.getOption(50 );
+        const fontFamilyVar = `--codelens-font-family${this._styleClassName}`;
+        const fontFeaturesVar = `--codelens-font-features${this._styleClassName}`;
+        let newStyle = `
+		.${this._styleClassName} { line-height: ${codeLensHeight}px; font-size: ${fontSize}px; padding-right: ${Math.round(fontSize * 0.5)}px; font-feature-settings: var(${fontFeaturesVar}) }
+		.monaco-workbench .${this._styleClassName} span.codicon { line-height: ${codeLensHeight}px; font-size: ${fontSize}px; }
+		`;
+        if (fontFamily) {
+            newStyle += `${this._styleClassName} { font-family: var(${fontFamilyVar}), ${EDITOR_FONT_DEFAULTS.fontFamily}}`;
+        }
+        this._styleElement.textContent = newStyle;
+        this._editor.getContainerDomNode().style.setProperty(fontFamilyVar, fontFamily ?? 'inherit');
+        this._editor.getContainerDomNode().style.setProperty(fontFeaturesVar, editorFontInfo.fontFeatureSettings);
+    }
+    _getLayoutInfo() {
+        const lineHeightFactor = Math.max(1.3, this._editor.getOption(66 ) / this._editor.getOption(52 ));
+        let fontSize = this._editor.getOption(19 );
+        if (!fontSize || fontSize < 5) {
+            fontSize = (this._editor.getOption(52 ) * .9) | 0;
+        }
+        return {
+            fontSize,
+            codeLensHeight: (fontSize * lineHeightFactor) | 0,
+        };
+    }
+    createWidget(viewZoneChangeAccessor, lineNumber, items, viewZoneIdsToCleanUp) {
+        const layoutInfo = this._getLayoutInfo();
+        return ( new ActionsContentWidget(
+            this._editor,
+            viewZoneChangeAccessor,
+            lineNumber,
+            layoutInfo.codeLensHeight + 2,
+            this._styleClassName,
+            items,
+            viewZoneIdsToCleanUp
+        ));
+    }
+}
+class ActionsSource {
+    constructor(viewModel, modifiedBaseRange) {
+        this.viewModel = viewModel;
+        this.modifiedBaseRange = modifiedBaseRange;
+        this.itemsInput1 = this.getItemsInput(1);
+        this.itemsInput2 = this.getItemsInput(2);
+        this.resultItems = derived(this, reader => {
+            const viewModel = this.viewModel;
+            const modifiedBaseRange = this.modifiedBaseRange;
+            const state = viewModel.model.getState(modifiedBaseRange).read(reader);
+            const model = viewModel.model;
+            const result = [];
+            if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
+                result.push({
+                    text: ( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'manualResolution',
+                        "Manual Resolution"
+                    )),
+                    tooltip: ( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'manualResolutionTooltip',
+                        "This conflict has been resolved manually."
+                    )),
+                });
+            }
+            else if (state.kind === ModifiedBaseRangeStateKind.base) {
+                result.push({
+                    text: ( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'noChangesAccepted',
+                        'No Changes Accepted'
+                    )),
+                    tooltip: ( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'noChangesAcceptedTooltip',
+                        'The current resolution of this conflict equals the common ancestor of both the right and left changes.'
+                    )),
+                });
+            }
+            else {
+                const labels = [];
+                if (state.includesInput1) {
+                    labels.push(model.input1.title);
+                }
+                if (state.includesInput2) {
+                    labels.push(model.input2.title);
+                }
+                if (state.kind === ModifiedBaseRangeStateKind.both && state.firstInput === 2) {
+                    labels.reverse();
+                }
+                result.push({
+                    text: `${labels.join(' + ')}`
+                });
+            }
+            const stateToggles = [];
+            if (state.includesInput1) {
+                stateToggles.push(command(( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                    'remove',
+                    'Remove {0}',
+                    model.input1.title
+                )), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, state.withInputValue(1, false), true, tx);
+                        model.telemetry.reportRemoveInvoked(1, state.includesInput(2));
+                    });
+                }, ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                    'removeTooltip',
+                    'Remove {0} from the result document.',
+                    model.input1.title
+                ))));
+            }
+            if (state.includesInput2) {
+                stateToggles.push(command(( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                    'remove',
+                    'Remove {0}',
+                    model.input2.title
+                )), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, state.withInputValue(2, false), true, tx);
+                        model.telemetry.reportRemoveInvoked(2, state.includesInput(1));
+                    });
+                }, ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                    'removeTooltip',
+                    'Remove {0} from the result document.',
+                    model.input2.title
+                ))));
+            }
+            if (state.kind === ModifiedBaseRangeStateKind.both &&
+                state.firstInput === 2) {
+                stateToggles.reverse();
+            }
+            result.push(...stateToggles);
+            if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
+                result.push(command(( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                    'resetToBase',
+                    'Reset to base'
+                )), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, ModifiedBaseRangeState.base, true, tx);
+                        model.telemetry.reportResetToBaseInvoked();
+                    });
+                }, ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                    'resetToBaseTooltip',
+                    'Reset this conflict to the common ancestor of both the right and left changes.'
+                ))));
+            }
+            return result;
+        });
+        this.isEmpty = derived(this, reader => {
+            return this.itemsInput1.read(reader).length + this.itemsInput2.read(reader).length + this.resultItems.read(reader).length === 0;
+        });
+        this.inputIsEmpty = derived(this, reader => {
+            return this.itemsInput1.read(reader).length + this.itemsInput2.read(reader).length === 0;
+        });
+    }
+    getItemsInput(inputNumber) {
+        return derived(reader => {
+            const viewModel = this.viewModel;
+            const modifiedBaseRange = this.modifiedBaseRange;
+            if (!viewModel.model.hasBaseRange(modifiedBaseRange)) {
+                return [];
+            }
+            const state = viewModel.model.getState(modifiedBaseRange).read(reader);
+            const handled = viewModel.model.isHandled(modifiedBaseRange).read(reader);
+            const model = viewModel.model;
+            const result = [];
+            const inputData = inputNumber === 1 ? viewModel.model.input1 : viewModel.model.input2;
+            const showNonConflictingChanges = viewModel.showNonConflictingChanges.read(reader);
+            if (!modifiedBaseRange.isConflicting && handled && !showNonConflictingChanges) {
+                return [];
+            }
+            const otherInputNumber = inputNumber === 1 ? 2 : 1;
+            if (state.kind !== ModifiedBaseRangeStateKind.unrecognized && !state.isInputIncluded(inputNumber)) {
+                if (!state.isInputIncluded(otherInputNumber) || !this.viewModel.shouldUseAppendInsteadOfAccept.read(reader)) {
+                    result.push(command(( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'accept',
+                        "Accept {0}",
+                        inputData.title
+                    )), async () => {
+                        transaction((tx) => {
+                            model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
+                            model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
+                        });
+                    }, ( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'acceptTooltip',
+                        "Accept {0} in the result document.",
+                        inputData.title
+                    ))));
+                    if (modifiedBaseRange.canBeCombined) {
+                        const commandName = modifiedBaseRange.isOrderRelevant
+                            ? ( localizeWithPath(
+                            'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                            'acceptBoth0First',
+                            "Accept Combination ({0} First)",
+                            inputData.title
+                        ))
+                            : ( localizeWithPath(
+                            'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                            'acceptBoth',
+                            "Accept Combination"
+                        ));
+                        result.push(command(commandName, async () => {
+                            transaction((tx) => {
+                                model.setState(modifiedBaseRange, ModifiedBaseRangeState.base
+                                    .withInputValue(inputNumber, true)
+                                    .withInputValue(otherInputNumber, true, true), true, tx);
+                                model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
+                            });
+                        }, ( localizeWithPath(
+                            'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                            'acceptBothTooltip',
+                            "Accept an automatic combination of both sides in the result document."
+                        ))));
+                    }
+                }
+                else {
+                    result.push(command(( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'append',
+                        "Append {0}",
+                        inputData.title
+                    )), async () => {
+                        transaction((tx) => {
+                            model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
+                            model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
+                        });
+                    }, ( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'appendTooltip',
+                        "Append {0} to the result document.",
+                        inputData.title
+                    ))));
+                    if (modifiedBaseRange.canBeCombined) {
+                        result.push(command(( localizeWithPath(
+                            'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                            'combine',
+                            "Accept Combination",
+                            inputData.title
+                        )), async () => {
+                            transaction((tx) => {
+                                model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, true), inputNumber, tx);
+                                model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
+                            });
+                        }, ( localizeWithPath(
+                            'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                            'acceptBothTooltip',
+                            "Accept an automatic combination of both sides in the result document."
+                        ))));
+                    }
+                }
+                if (!model.isInputHandled(modifiedBaseRange, inputNumber).read(reader)) {
+                    result.push(command(( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'ignore',
+                        'Ignore'
+                    )), async () => {
+                        transaction((tx) => {
+                            model.setInputHandled(modifiedBaseRange, inputNumber, true, tx);
+                        });
+                    }, ( localizeWithPath(
+                        'vs/workbench/contrib/mergeEditor/browser/view/conflictActions',
+                        'markAsHandledTooltip',
+                        "Don't take this side of the conflict."
+                    ))));
+                }
+            }
+            return result;
+        });
+    }
+}
+function command(title, action, tooltip) {
+    return {
+        text: title,
+        action,
+        tooltip,
+    };
+}
+class ActionsContentWidget extends FixedZoneWidget {
+    constructor(editor, viewZoneAccessor, afterLineNumber, height, className, items, viewZoneIdsToCleanUp) {
+        super(editor, viewZoneAccessor, afterLineNumber, height, viewZoneIdsToCleanUp);
+        this._domNode = h('div.merge-editor-conflict-actions').root;
+        this.widgetDomNode.appendChild(this._domNode);
+        this._domNode.classList.add(className);
+        this._register(autorun(reader => {
+            const i = items.read(reader);
+            this.setState(i);
+        }));
+    }
+    setState(items) {
+        const children = [];
+        let isFirst = true;
+        for (const item of items) {
+            if (isFirst) {
+                isFirst = false;
+            }
+            else {
+                children.push($('span', undefined, '\u00a0|\u00a0'));
+            }
+            const title = renderLabelWithIcons(item.text);
+            if (item.action) {
+                children.push($('a', { title: item.tooltip, role: 'button', onclick: () => item.action() }, ...title));
+            }
+            else {
+                children.push($('span', { title: item.tooltip }, ...title));
+            }
+        }
+        reset(this._domNode, ...children);
+    }
+}
+export { ActionsSource, ConflictActionsFactory };

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

@@ -0,0 +1,96 @@
+import { h, reset } from '../../../../../base/browser/dom.js';
+import { Disposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { LineRange } from '../model/lineRange.js';
+import { observableFromEvent, observableSignalFromEvent, observableSignal } from '../../../../../base/common/observableInternal/utils.js';
+import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
+import { transaction } from '../../../../../base/common/observableInternal/base.js';
+class EditorGutter extends Disposable {
+    constructor(_editor, _domNode, itemProvider) {
+        super();
+        this._editor = _editor;
+        this._domNode = _domNode;
+        this.itemProvider = itemProvider;
+        this.scrollTop = observableFromEvent(this._editor.onDidScrollChange, (e) =>  this._editor.getScrollTop());
+        this.isScrollTopZero = ( this.scrollTop.map((scrollTop) =>  scrollTop === 0));
+        this.modelAttached = observableFromEvent(this._editor.onDidChangeModel, (e) =>  this._editor.hasModel());
+        this.editorOnDidChangeViewZones = observableSignalFromEvent('onDidChangeViewZones', this._editor.onDidChangeViewZones);
+        this.editorOnDidContentSizeChange = observableSignalFromEvent('onDidContentSizeChange', this._editor.onDidContentSizeChange);
+        this.domNodeSizeChanged = observableSignal('domNodeSizeChanged');
+        this.views = ( new Map());
+        this._domNode.className = 'gutter monaco-editor';
+        const scrollDecoration = this._domNode.appendChild(h('div.scroll-decoration', { role: 'presentation', ariaHidden: 'true', style: { width: '100%' } })
+            .root);
+        const o = ( new ResizeObserver(() => {
+            transaction(tx => {
+                this.domNodeSizeChanged.trigger(tx);
+            });
+        }));
+        o.observe(this._domNode);
+        this._register(toDisposable(() => o.disconnect()));
+        this._register(autorun(reader => {
+            scrollDecoration.className = this.isScrollTopZero.read(reader) ? '' : 'scroll-decoration';
+        }));
+        this._register(autorun(reader =>  this.render(reader)));
+    }
+    dispose() {
+        super.dispose();
+        reset(this._domNode);
+    }
+    render(reader) {
+        if (!this.modelAttached.read(reader)) {
+            return;
+        }
+        this.domNodeSizeChanged.read(reader);
+        this.editorOnDidChangeViewZones.read(reader);
+        this.editorOnDidContentSizeChange.read(reader);
+        const scrollTop = this.scrollTop.read(reader);
+        const visibleRanges = this._editor.getVisibleRanges();
+        const unusedIds = ( new Set(( this.views.keys())));
+        if (visibleRanges.length > 0) {
+            const visibleRange = visibleRanges[0];
+            const visibleRange2 = ( new LineRange(
+                visibleRange.startLineNumber,
+                visibleRange.endLineNumber - visibleRange.startLineNumber
+            )).deltaEnd(1);
+            const gutterItems = this.itemProvider.getIntersectingGutterItems(visibleRange2, reader);
+            for (const gutterItem of gutterItems) {
+                if (!gutterItem.range.touches(visibleRange2)) {
+                    continue;
+                }
+                unusedIds.delete(gutterItem.id);
+                let view = this.views.get(gutterItem.id);
+                if (!view) {
+                    const viewDomNode = document.createElement('div');
+                    this._domNode.appendChild(viewDomNode);
+                    const itemView = this.itemProvider.createView(gutterItem, viewDomNode);
+                    view = ( new ManagedGutterItemView(itemView, viewDomNode));
+                    this.views.set(gutterItem.id, view);
+                }
+                else {
+                    view.gutterItemView.update(gutterItem);
+                }
+                const top = gutterItem.range.startLineNumber <= this._editor.getModel().getLineCount()
+                    ? this._editor.getTopForLineNumber(gutterItem.range.startLineNumber, true) - scrollTop
+                    : this._editor.getBottomForLineNumber(gutterItem.range.startLineNumber - 1, false) - scrollTop;
+                const bottom = this._editor.getBottomForLineNumber(gutterItem.range.endLineNumberExclusive - 1, true) - scrollTop;
+                const height = bottom - top;
+                view.domNode.style.top = `${top}px`;
+                view.domNode.style.height = `${height}px`;
+                view.gutterItemView.layout(top, height, 0, this._domNode.clientHeight);
+            }
+        }
+        for (const id of unusedIds) {
+            const view = this.views.get(id);
+            view.gutterItemView.dispose();
+            this._domNode.removeChild(view.domNode);
+            this.views.delete(id);
+        }
+    }
+}
+class ManagedGutterItemView {
+    constructor(gutterItemView, domNode) {
+        this.gutterItemView = gutterItemView;
+        this.domNode = domNode;
+    }
+}
+export { EditorGutter };

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

@@ -0,0 +1,144 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { reset, h } from '../../../../../../base/browser/dom.js';
+import { renderLabelWithIcons } from '../../../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { BugIndicatingError } from '../../../../../../base/common/errors.js';
+import { MinimapPosition, OverviewRulerLane } from '../../../../../../editor/common/model.js';
+import { localizeWithPath } from '../../../../../../nls.js';
+import { MenuId } from '../../../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { applyObservableDecorations } from '../../utils.js';
+import { handledConflictMinimapOverViewRulerColor, unhandledConflictMinimapOverViewRulerColor } from '../colors.js';
+import { EditorGutter } from '../editorGutter.js';
+import { CodeEditorView, createSelectionsAutorun, TitleMenu } from './codeEditorView.js';
+import { derived } from '../../../../../../base/common/observableInternal/derived.js';
+import { autorunWithStore, autorun } from '../../../../../../base/common/observableInternal/autorun.js';
+let BaseCodeEditorView = class BaseCodeEditorView extends CodeEditorView {
+    constructor(viewModel, instantiationService, configurationService) {
+        super(instantiationService, viewModel, configurationService);
+        this.decorations = derived(this, reader => {
+            const viewModel = this.viewModel.read(reader);
+            if (!viewModel) {
+                return [];
+            }
+            const model = viewModel.model;
+            const textModel = model.base;
+            const activeModifiedBaseRange = viewModel.activeModifiedBaseRange.read(reader);
+            const showNonConflictingChanges = viewModel.showNonConflictingChanges.read(reader);
+            const showDeletionMarkers = this.showDeletionMarkers.read(reader);
+            const result = [];
+            for (const modifiedBaseRange of model.modifiedBaseRanges.read(reader)) {
+                const range = modifiedBaseRange.baseRange;
+                if (!range) {
+                    continue;
+                }
+                const isHandled = model.isHandled(modifiedBaseRange).read(reader);
+                if (!modifiedBaseRange.isConflicting && isHandled && !showNonConflictingChanges) {
+                    continue;
+                }
+                const blockClassNames = ['merge-editor-block'];
+                let blockPadding = [0, 0, 0, 0];
+                if (isHandled) {
+                    blockClassNames.push('handled');
+                }
+                if (modifiedBaseRange === activeModifiedBaseRange) {
+                    blockClassNames.push('focused');
+                    blockPadding = [0, 2, 0, 2];
+                }
+                blockClassNames.push('base');
+                const inputToDiffAgainst = viewModel.baseShowDiffAgainst.read(reader);
+                if (inputToDiffAgainst) {
+                    for (const diff of modifiedBaseRange.getInputDiffs(inputToDiffAgainst)) {
+                        const range = diff.inputRange.toInclusiveRange();
+                        if (range) {
+                            result.push({
+                                range,
+                                options: {
+                                    className: `merge-editor-diff base`,
+                                    description: 'Merge Editor',
+                                    isWholeLine: true,
+                                }
+                            });
+                        }
+                        for (const diff2 of diff.rangeMappings) {
+                            if (showDeletionMarkers || !diff2.inputRange.isEmpty()) {
+                                result.push({
+                                    range: diff2.inputRange,
+                                    options: {
+                                        className: diff2.inputRange.isEmpty() ? `merge-editor-diff-empty-word base` : `merge-editor-diff-word base`,
+                                        description: 'Merge Editor',
+                                        showIfCollapsed: true,
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+                result.push({
+                    range: range.toInclusiveRangeOrEmpty(),
+                    options: {
+                        showIfCollapsed: true,
+                        blockClassName: blockClassNames.join(' '),
+                        blockPadding,
+                        blockIsAfterEnd: range.startLineNumber > textModel.getLineCount(),
+                        description: 'Merge Editor',
+                        minimap: {
+                            position: MinimapPosition.Gutter,
+                            color: { id: isHandled ? handledConflictMinimapOverViewRulerColor : unhandledConflictMinimapOverViewRulerColor },
+                        },
+                        overviewRuler: modifiedBaseRange.isConflicting ? {
+                            position: OverviewRulerLane.Center,
+                            color: { id: isHandled ? handledConflictMinimapOverViewRulerColor : unhandledConflictMinimapOverViewRulerColor },
+                        } : undefined
+                    }
+                });
+            }
+            return result;
+        });
+        this._register(createSelectionsAutorun(this, (baseRange, viewModel) => baseRange));
+        this._register(instantiationService.createInstance(TitleMenu, MenuId.MergeBaseToolbar, this.htmlElements.title));
+        this._register(autorunWithStore((reader, store) => {
+            if (this.checkboxesVisible.read(reader)) {
+                store.add(( new EditorGutter(this.editor, this.htmlElements.gutterDiv, {
+                    getIntersectingGutterItems: (range, reader) => [],
+                    createView: (item, target) => { throw new BugIndicatingError(); },
+                })));
+            }
+        }));
+        this._register(autorun(reader => {
+            const vm = this.viewModel.read(reader);
+            if (!vm) {
+                return;
+            }
+            this.editor.setModel(vm.model.base);
+            reset(this.htmlElements.title, ...renderLabelWithIcons(( localizeWithPath(
+                'vs/workbench/contrib/mergeEditor/browser/view/editors/baseCodeEditorView',
+                'base',
+                'Base'
+            ))));
+            const baseShowDiffAgainst = vm.baseShowDiffAgainst.read(reader);
+            let node = undefined;
+            if (baseShowDiffAgainst) {
+                const label = ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/editors/baseCodeEditorView',
+                    'compareWith',
+                    'Comparing with {0}',
+                    baseShowDiffAgainst === 1 ? vm.model.input1.title : vm.model.input2.title
+                ));
+                const tooltip = ( localizeWithPath(
+                    'vs/workbench/contrib/mergeEditor/browser/view/editors/baseCodeEditorView',
+                    'compareWithTooltip',
+                    'Differences are highlighted with a background color.'
+                ));
+                node = h('span', { title: tooltip }, [label]).root;
+            }
+            reset(this.htmlElements.description, ...(node ? [node] : []));
+        }));
+        this._register(applyObservableDecorations(this.editor, this.decorations));
+    }
+};
+BaseCodeEditorView = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService))
+], BaseCodeEditorView));
+export { BaseCodeEditorView };