@theia/scm 1.64.0-next.28 → 1.64.0

package/src/browser/merge-editor/view/merge-editor-panes/merge-editor-base-pane.ts

@@ -0,0 +1,71 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { nls } from '@theia/core';
+import { Autorun } from '@theia/core/lib/common/observable';
+import { EditorDecoration, Range } from '@theia/editor/lib/browser';
+import { MergeEditorPane } from './merge-editor-pane';
+import { MergeRange } from '../../model/merge-range';
+import { LineRange } from '../../model/line-range';
+
+@injectable()
+export class MergeEditorBasePane extends MergeEditorPane {
+
+    constructor() {
+        super();
+        this.addClass('base');
+    }
+
+    override getLineRangeForMergeRange(mergeRange: MergeRange): LineRange {
+        return mergeRange.baseRange;
+    }
+
+    protected override translateBaseRange(range: Range): Range {
+        return range;
+    }
+
+    protected override onAfterMergeEditorSet(): void {
+        super.onAfterMergeEditorSet();
+        this.toDispose.push(Autorun.create(() => {
+            const { currentPane, side1Pane, side1Title, side2Pane, side2Title } = this.mergeEditor;
+            this.header.description = currentPane === this ? '' : nls.localizeByDefault('Comparing with {0}',
+                currentPane === side1Pane ? side1Title : currentPane === side2Pane ? side2Title : nls.localizeByDefault('Result')
+            );
+        }));
+    }
+
+    protected override computeEditorDecorations(): EditorDecoration[] {
+        const result: EditorDecoration[] = [];
+
+        const { model, currentPane, side1Pane, side2Pane, currentMergeRange } = this.mergeEditor;
+
+        for (const mergeRange of model.mergeRanges) {
+            const lineRange = mergeRange.baseRange;
+            result.push(this.toMergeRangeDecoration(lineRange, {
+                isHandled: model.isMergeRangeHandled(mergeRange),
+                isFocused: mergeRange === currentMergeRange,
+                isAfterEnd: lineRange.startLineNumber > model.baseDocument.lineCount,
+            }));
+        }
+
+        if (currentPane !== this) {
+            const changes = currentPane === side1Pane ? model.side1Changes : currentPane === side2Pane ? model.side2Changes : model.resultChanges;
+            result.push(...this.toChangeDecorations(changes, { diffSide: 'original' }));
+        }
+        return result;
+    }
+}

package/src/browser/merge-editor/view/merge-editor-panes/merge-editor-pane-header.tsx

@@ -0,0 +1,106 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import * as React from '@theia/core/shared/react';
+import { codicon, Message, onDomEvent, ReactWidget } from '@theia/core/lib/browser';
+import { LabelParser } from '@theia/core/lib/browser/label-parser';
+
+@injectable()
+export class MergeEditorPaneHeader extends ReactWidget {
+
+    @inject(LabelParser)
+    protected readonly labelParser: LabelParser;
+
+    private _description = '';
+    get description(): string {
+        return this._description;
+    }
+    set description(description: string) {
+        this._description = description;
+        this.update();
+    }
+
+    private _detail = '';
+    get detail(): string {
+        return this._detail;
+    }
+    set detail(detail: string) {
+        this._detail = detail;
+        this.update();
+    }
+
+    private _toolbarItems: readonly MergeEditorPaneToolbarItem[];
+    get toolbarItems(): readonly MergeEditorPaneToolbarItem[] {
+        return this._toolbarItems;
+    }
+    set toolbarItems(toolbarItems: readonly MergeEditorPaneToolbarItem[]) {
+        this._toolbarItems = toolbarItems;
+        this.update();
+    }
+
+    @postConstruct()
+    protected init(): void {
+        this.addClass('header');
+        this.scrollOptions = undefined;
+        this.node.tabIndex = -1;
+        this.toDispose.push(onDomEvent(this.node, 'click', () => this.activate()));
+        this.title.changed.connect(this.update, this);
+    }
+
+    protected override onActivateRequest(msg: Message): void {
+        super.onActivateRequest(msg);
+        this.parent?.activate();
+    }
+
+    protected override render(): React.ReactNode {
+        return (
+            <React.Fragment>
+                <span className='title'>{this.renderWithIcons(this.title.label)}</span>
+                <span className='description'>{this.renderWithIcons(this.description)}</span>
+                <span className='detail'>{this.renderWithIcons(this.detail)}</span>
+                <span className='toolbar' onClick={this.handleToolbarClick}>{this.toolbarItems.map(toolbarItem => this.renderToolbarItem(toolbarItem))}</span>
+            </React.Fragment>
+        );
+    }
+
+    private readonly handleToolbarClick = (event: React.MouseEvent) => event.nativeEvent.stopImmediatePropagation();
+
+    protected renderWithIcons(text: string): React.ReactNode[] {
+        const result: React.ReactNode[] = [];
+        const labelParts = this.labelParser.parse(text);
+        labelParts.forEach((labelPart, index) => {
+            if (typeof labelPart === 'string') {
+                result.push(labelPart);
+            } else {
+                result.push(<span key={index} className={codicon(labelPart.name)}></span>);
+            }
+        });
+        return result;
+    }
+
+    protected renderToolbarItem({ id, label, tooltip, className, onClick }: MergeEditorPaneToolbarItem): React.ReactNode {
+        return <span key={id} title={tooltip} onClick={onClick} className={className}>{label}</span>;
+    }
+}
+
+export interface MergeEditorPaneToolbarItem {
+    readonly id: string;
+    readonly label?: string;
+    readonly tooltip?: string;
+    readonly className?: string;
+    readonly onClick?: (event: React.MouseEvent) => void;
+}

package/src/browser/merge-editor/view/merge-editor-panes/merge-editor-pane.ts

@@ -0,0 +1,246 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { Disposable, DisposableCollection } from '@theia/core';
+import { Autorun, DerivedObservable, Observable, ObservableFromEvent } from '@theia/core/lib/common/observable';
+import { BoxPanel, Message } from '@theia/core/lib/browser';
+import { EditorDecoration, EditorWidget, MinimapPosition, OverviewRulerLane, Position, Range, TrackedRangeStickiness } from '@theia/editor/lib/browser';
+import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
+import { MonacoToProtocolConverter } from '@theia/monaco/lib/browser/monaco-to-protocol-converter';
+import { Selection } from '@theia/monaco-editor-core';
+import { MergeEditorPaneHeader, MergeEditorPaneToolbarItem } from './merge-editor-pane-header';
+import { MergeEditor } from '../../merge-editor';
+import { MergeRange } from '../../model/merge-range';
+import { DetailedLineRangeMapping } from '../../model/range-mapping';
+import { LineRange } from '../../model/line-range';
+import { RangeUtils } from '../../model/range-utils';
+import { ScmColors } from '../../../scm-colors';
+
+@injectable()
+export abstract class MergeEditorPane extends BoxPanel {
+
+    @inject(MergeEditorPaneHeader)
+    readonly header: MergeEditorPaneHeader;
+
+    @inject(EditorWidget)
+    readonly editorWidget: EditorWidget;
+
+    @inject(MonacoToProtocolConverter)
+    private readonly m2p: MonacoToProtocolConverter;
+
+    get editor(): MonacoEditor {
+        return MonacoEditor.get(this.editorWidget)!;
+    }
+
+    protected _mergeEditor: MergeEditor;
+
+    protected cursorPositionObservable: Observable<Position>;
+    protected cursorLineObservable: Observable<number>;
+    protected selectionObservable: Observable<Range[] | undefined>;
+
+    protected readonly toDispose = new DisposableCollection();
+
+    constructor() {
+        super({ spacing: 0 });
+        this.addClass('editor-pane');
+    }
+
+    @postConstruct()
+    protected init(): void {
+        this.cursorPositionObservable = ObservableFromEvent.create(this.editor.onCursorPositionChanged, () => this.editor.cursor);
+        this.cursorLineObservable = DerivedObservable.create(() => this.cursorPositionObservable.get().line);
+        this.selectionObservable = ObservableFromEvent.create(this.editor.getControl().onDidChangeCursorSelection, () => {
+            const selections = this.editor.getControl().getSelections();
+            return selections?.map(selection => this.m2p.asRange(selection));
+        });
+
+        BoxPanel.setStretch(this.header, 0);
+        BoxPanel.setStretch(this.editorWidget, 1);
+
+        this.addWidget(this.header);
+        this.addWidget(this.editorWidget);
+    }
+
+    override dispose(): void {
+        super.dispose();
+        this.toDispose.dispose();
+    }
+
+    get mergeEditor(): MergeEditor {
+        return this._mergeEditor;
+    }
+
+    set mergeEditor(mergeEditor: MergeEditor) {
+        if (this._mergeEditor) {
+            throw new Error('Merge editor has already been set');
+        }
+        this._mergeEditor = mergeEditor;
+        this.onAfterMergeEditorSet();
+    }
+
+    protected onAfterMergeEditorSet(): void {
+        this.initContextKeys();
+
+        const toolbarItems = DerivedObservable.create(() => this.getToolbarItems());
+        this.toDispose.push(Autorun.create(() => {
+            this.header.toolbarItems = toolbarItems.get();
+        }));
+
+        this.initSelectionSynchronizer();
+
+        let decorationIds: string[] = [];
+        const decorations = DerivedObservable.create(() => this.computeEditorDecorations());
+        const isVisible = ObservableFromEvent.create(this.editorWidget.onDidChangeVisibility, () => this.editorWidget.isVisible);
+
+        this.toDispose.push(Autorun.create(() => {
+            if (this.mergeEditor.isShown && isVisible.get()) {
+                decorationIds = this.editor.deltaDecorations({ oldDecorations: decorationIds, newDecorations: decorations.get() });
+            }
+        }));
+        this.toDispose.push(Disposable.create(() =>
+            decorationIds = this.editor.deltaDecorations({ oldDecorations: decorationIds, newDecorations: [] })
+        ));
+    }
+
+    get cursorPosition(): Position {
+        return this.cursorPositionObservable.get();
+    }
+
+    get cursorLine(): number {
+        return this.cursorLineObservable.get();
+    }
+
+    get selection(): Range[] | undefined {
+        return this.selectionObservable.get();
+    }
+
+    goToMergeRange(mergeRange: MergeRange, options?: { reveal?: boolean }): void {
+        const { editor } = this;
+        const { startLineNumber, endLineNumberExclusive } = this.getLineRangeForMergeRange(mergeRange);
+        editor.cursor = { line: startLineNumber, character: 0 };
+        const reveal = options?.reveal ?? true;
+        if (reveal) {
+            editor.getControl().revealLinesNearTop(startLineNumber + 1, endLineNumberExclusive + 1);
+        }
+    }
+
+    abstract getLineRangeForMergeRange(mergeRange: MergeRange): LineRange;
+
+    protected abstract translateBaseRange(range: Range): Range;
+
+    protected getToolbarItems(): MergeEditorPaneToolbarItem[] {
+        return [];
+    }
+
+    protected computeEditorDecorations(): EditorDecoration[] {
+        return [];
+    }
+
+    protected toMergeRangeDecoration(lineRange: LineRange,
+        { isHandled, isFocused, isAfterEnd }: { isHandled: boolean, isFocused: boolean, isAfterEnd: boolean }
+    ): EditorDecoration {
+        const blockClassNames = ['merge-range'];
+        let blockPadding: [top: number, right: number, bottom: number, left: number] = [0, 0, 0, 0];
+        if (isHandled) {
+            blockClassNames.push('handled');
+        }
+        if (isFocused) {
+            blockClassNames.push('focused');
+            blockPadding = [0, 2, 0, 2];
+        }
+        return {
+            range: lineRange.toInclusiveRangeOrEmpty(),
+            options: {
+                blockClassName: blockClassNames.join(' '),
+                blockPadding,
+                blockIsAfterEnd: isAfterEnd,
+                minimap: {
+                    position: MinimapPosition.Gutter,
+                    color: { id: isHandled ? ScmColors.handledConflictMinimapOverviewRulerColor : ScmColors.unhandledConflictMinimapOverviewRulerColor },
+                },
+                overviewRuler: {
+                    position: OverviewRulerLane.Center,
+                    color: { id: isHandled ? ScmColors.handledConflictMinimapOverviewRulerColor : ScmColors.unhandledConflictMinimapOverviewRulerColor },
+                },
+                showIfCollapsed: true,
+                stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+            }
+        };
+    }
+
+    protected toChangeDecorations(changes: readonly DetailedLineRangeMapping[],
+        { diffSide }: { diffSide: 'original' | 'modified' }
+    ): EditorDecoration[] {
+        const result: EditorDecoration[] = [];
+        for (const change of changes) {
+            const changeRange = (diffSide === 'original' ? change.originalRange : change.modifiedRange).toInclusiveRange();
+            if (changeRange) {
+                result.push({
+                    range: changeRange,
+                    options: {
+                        className: 'diff',
+                        isWholeLine: true,
+                        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+                    }
+                });
+            }
+
+            for (const rangeMapping of change.rangeMappings) {
+                const range = diffSide === 'original' ? rangeMapping.originalRange : rangeMapping.modifiedRange;
+                result.push({
+                    range,
+                    options: {
+                        className: RangeUtils.isEmpty(range) ? 'diff-empty-word' : 'diff-word',
+                        showIfCollapsed: true,
+                        stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+                    },
+                });
+            }
+        }
+        return result;
+    }
+
+    protected initContextKeys(): void {
+        const editor = this.editor.getControl();
+        editor.createContextKey('isMergeEditor', true);
+        editor.createContextKey('mergeEditorBaseUri', this.mergeEditor.baseUri.toString());
+        editor.createContextKey('mergeEditorResultUri', this.mergeEditor.resultUri.toString());
+    }
+
+    protected initSelectionSynchronizer(): void {
+        const selectionObservable = DerivedObservable.create(() => {
+            const { selectionInBase, currentPane } = this.mergeEditor;
+            if (!selectionInBase || currentPane === this) {
+                return [];
+            }
+            return selectionInBase.map(range => this.translateBaseRange(range));
+        });
+        this.toDispose.push(Autorun.create(() => {
+            const selection = selectionObservable.get();
+            if (selection.length) {
+                this.editor.getControl().setSelections(selection.map(
+                    ({ start, end }) => new Selection(start.line + 1, start.character + 1, end.line + 1, end.character + 1)
+                ));
+            }
+        }));
+    }
+
+    protected override onActivateRequest(msg: Message): void {
+        super.onActivateRequest(msg);
+        this.editorWidget.activate();
+    }
+}

package/src/browser/merge-editor/view/merge-editor-panes/merge-editor-result-pane.ts

@@ -0,0 +1,115 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { nls } from '@theia/core';
+import { ACTION_ITEM, codicon, ConfirmDialog, Dialog, DISABLED_CLASS } from '@theia/core/lib/browser';
+import { ObservableUtils } from '@theia/core/lib/common/observable';
+import { EditorDecoration, Range } from '@theia/editor/lib/browser';
+import { MergeEditorPane } from './merge-editor-pane';
+import { MergeEditorPaneToolbarItem } from './merge-editor-pane-header';
+import { LineRange } from '../../model/line-range';
+import { MergeRange } from '../../model/merge-range';
+
+@injectable()
+export class MergeEditorResultPane extends MergeEditorPane {
+
+    constructor() {
+        super();
+        this.addClass('result');
+    }
+
+    protected override initContextKeys(): void {
+        super.initContextKeys();
+        this.editor.getControl().createContextKey('isMergeResultEditor', true);
+    }
+
+    override getLineRangeForMergeRange(mergeRange: MergeRange): LineRange {
+        return this.mergeEditor.model.getLineRangeInResult(mergeRange);
+    }
+
+    protected override translateBaseRange(range: Range): Range {
+        return this.mergeEditor.model.translateBaseRangeToResult(range);
+    }
+
+    protected goToNextUnhandledMergeRange(): void {
+        this.mergeEditor.goToNextMergeRange(mergeRange => !this.mergeEditor.model.isMergeRangeHandled(mergeRange));
+        this.mergeEditor.activate();
+    }
+
+    reset(): void {
+        new ConfirmDialog({
+            title: nls.localize('theia/scm/mergeEditor/resetConfirmationTitle', 'Do you really want to reset the merge result in this editor?'),
+            msg: nls.localize('theia/scm/mergeEditor/resetConfirmationMessage', 'This action cannot be undone.'),
+            ok: Dialog.YES,
+            cancel: Dialog.NO,
+        }).open().then(async confirmed => {
+            if (confirmed) {
+                this.activate();
+                const { model } = this.mergeEditor;
+                await model.reset();
+                await ObservableUtils.waitForState(model.isUpToDateObservable);
+                this.mergeEditor.goToFirstMergeRange(mergeRange => !model.isMergeRangeHandled(mergeRange));
+            }
+        }).catch(e => console.error(e));
+    }
+
+    protected override getToolbarItems(): MergeEditorPaneToolbarItem[] {
+        const { model } = this.mergeEditor;
+        const { unhandledMergeRangesCount } = model;
+        return [
+            {
+                id: 'nextConflict',
+                label: unhandledMergeRangesCount === 1 ?
+                    nls.localizeByDefault('{0} Conflict Remaining', unhandledMergeRangesCount) :
+                    nls.localizeByDefault('{0} Conflicts Remaining ', unhandledMergeRangesCount),
+                tooltip: unhandledMergeRangesCount ?
+                    nls.localizeByDefault('Go to next conflict') :
+                    nls.localizeByDefault('All conflicts handled, the merge can be completed now.'),
+                className: ACTION_ITEM + (unhandledMergeRangesCount ? '' : ' ' + DISABLED_CLASS),
+                onClick: unhandledMergeRangesCount ?
+                    () => this.goToNextUnhandledMergeRange() :
+                    undefined
+            },
+            {
+                id: 'reset',
+                tooltip: nls.localizeByDefault('Reset'),
+                className: codicon('discard', true),
+                onClick: () => this.reset()
+            }
+        ];
+    }
+
+    protected override computeEditorDecorations(): EditorDecoration[] {
+        const result: EditorDecoration[] = [];
+
+        const { model, currentMergeRange } = this.mergeEditor;
+
+        for (const mergeRange of model.mergeRanges) {
+            if (mergeRange) {
+                const lineRange = model.getLineRangeInResult(mergeRange);
+                result.push(this.toMergeRangeDecoration(lineRange, {
+                    isHandled: model.isMergeRangeHandled(mergeRange),
+                    isFocused: mergeRange === currentMergeRange,
+                    isAfterEnd: lineRange.startLineNumber > model.resultDocument.lineCount,
+                }));
+            }
+        }
+
+        result.push(...this.toChangeDecorations(model.resultChanges, { diffSide: 'modified' }));
+        return result;
+    }
+}

package/src/browser/merge-editor/view/merge-editor-panes/merge-editor-side-pane.ts

@@ -0,0 +1,139 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { nls } from '@theia/core';
+import { ObservableUtils } from '@theia/core/lib/common/observable';
+import { codicon, DiffUris, LabelProvider, open, OpenerService } from '@theia/core/lib/browser';
+import { EditorDecoration, EditorOpenerOptions, Range } from '@theia/editor/lib/browser';
+import { MergeRange, MergeRangeAcceptedState, MergeSide } from '../../model/merge-range';
+import { MergeEditorPane } from './merge-editor-pane';
+import { MergeEditorPaneToolbarItem } from './merge-editor-pane-header';
+import { LineRange } from '../../model/line-range';
+
+@injectable()
+export abstract class MergeEditorSidePane extends MergeEditorPane {
+
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    abstract get mergeSide(): MergeSide;
+
+    constructor() {
+        super();
+        this.addClass('side');
+    }
+
+    override getLineRangeForMergeRange(mergeRange: MergeRange): LineRange {
+        return mergeRange.getModifiedRange(this.mergeSide);
+    }
+
+    protected override translateBaseRange(range: Range): Range {
+        return this.mergeEditor.model.translateBaseRangeToSide(range, this.mergeSide);
+    }
+
+    async acceptAllChanges(): Promise<void> {
+        const { model, resultPane } = this.mergeEditor;
+        resultPane.activate();
+        const selections = resultPane.editor.getControl().getSelections();
+        for (const mergeRange of model.mergeRanges) {
+            await ObservableUtils.waitForState(model.isUpToDateObservable);
+            resultPane.goToMergeRange(mergeRange, { reveal: false });
+            let state = model.getMergeRangeResultState(mergeRange);
+            if (state === 'Unrecognized') {
+                state = 'Base';
+            }
+            model.applyMergeRangeAcceptedState(mergeRange, MergeRangeAcceptedState.addSide(state, this.mergeSide));
+        }
+        if (selections) {
+            resultPane.editor.getControl().setSelections(selections);
+        }
+    }
+
+    compareWithBase(): void {
+        let label = this.labelProvider.getName(this.editor.uri);
+        if (label) {
+            label += ': ';
+        }
+        label += `${nls.localizeByDefault('Base')} ⟷ ${this.header.title.label}`;
+        const options: EditorOpenerOptions = { selection: { start: this.editor.cursor } };
+        open(this.openerService, DiffUris.encode(this.mergeEditor.baseUri, this.editor.uri, label), options).catch(e => {
+            console.error(e);
+        });
+    }
+
+    protected override getToolbarItems(): MergeEditorPaneToolbarItem[] {
+        return [
+            {
+                id: 'acceptAllChanges',
+                tooltip: nls.localizeByDefault(this.mergeSide === 1 ? 'Accept All Changes from Left' : 'Accept All Changes from Right'),
+                className: codicon('check-all', true),
+                onClick: () => this.acceptAllChanges()
+            },
+            {
+                id: 'compareWithBase',
+                tooltip: nls.localizeByDefault('Compare With Base'),
+                className: codicon('compare-changes', true),
+                onClick: () => this.compareWithBase()
+            }
+        ];
+    }
+
+    protected override computeEditorDecorations(): EditorDecoration[] {
+        const result: EditorDecoration[] = [];
+
+        const { model, currentMergeRange } = this.mergeEditor;
+        const document = this.mergeSide === 1 ? model.side1Document : model.side2Document;
+
+        for (const mergeRange of model.mergeRanges) {
+            const lineRange = mergeRange.getModifiedRange(this.mergeSide);
+            result.push(this.toMergeRangeDecoration(lineRange, {
+                isHandled: model.isMergeRangeHandled(mergeRange),
+                isFocused: mergeRange === currentMergeRange,
+                isAfterEnd: lineRange.startLineNumber > document.lineCount,
+            }));
+        }
+
+        const changes = this.mergeSide === 1 ? model.side1Changes : model.side2Changes;
+        result.push(...this.toChangeDecorations(changes, { diffSide: 'modified' }));
+        return result;
+    }
+}
+
+@injectable()
+export class MergeEditorSide1Pane extends MergeEditorSidePane {
+
+    readonly mergeSide = 1;
+
+    constructor() {
+        super();
+        this.addClass('side1');
+    }
+}
+
+@injectable()
+export class MergeEditorSide2Pane extends MergeEditorSidePane {
+
+    readonly mergeSide = 2;
+
+    constructor() {
+        super();
+        this.addClass('side2');
+    }
+}