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

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

@@ -0,0 +1,156 @@
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { DocumentLineRangeMap } from '../model/mapping.js';
+import { ReentrancyBarrier } from '../utils.js';
+import { autorunWithStore } from '../../../../../base/common/observableInternal/autorun.js';
+class ScrollSynchronizer extends Disposable {
+    get model() { return this.viewModel.get()?.model; }
+    get shouldAlignResult() { return this.layout.get().kind === 'columns'; }
+    get shouldAlignBase() { return this.layout.get().kind === 'mixed' && !this.layout.get().showBaseAtTop; }
+    constructor(viewModel, input1View, input2View, baseView, inputResultView, layout) {
+        super();
+        this.viewModel = viewModel;
+        this.input1View = input1View;
+        this.input2View = input2View;
+        this.baseView = baseView;
+        this.inputResultView = inputResultView;
+        this.layout = layout;
+        this.reentrancyBarrier = ( new ReentrancyBarrier());
+        const handleInput1OnScroll = this.updateScrolling = () => {
+            if (!this.model) {
+                return;
+            }
+            this.input2View.editor.setScrollTop(this.input1View.editor.getScrollTop(), 1 );
+            if (this.shouldAlignResult) {
+                this.inputResultView.editor.setScrollTop(this.input1View.editor.getScrollTop(), 1 );
+            }
+            else {
+                const mappingInput1Result = this.model.input1ResultMapping.get();
+                this.synchronizeScrolling(this.input1View.editor, this.inputResultView.editor, mappingInput1Result);
+            }
+            const baseView = this.baseView.get();
+            if (baseView) {
+                if (this.shouldAlignBase) {
+                    this.baseView.get()?.editor.setScrollTop(this.input1View.editor.getScrollTop(), 1 );
+                }
+                else {
+                    const mapping = ( new DocumentLineRangeMap(this.model.baseInput1Diffs.get(), -1)).reverse();
+                    this.synchronizeScrolling(this.input1View.editor, baseView.editor, mapping);
+                }
+            }
+        };
+        this._store.add(this.input1View.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
+            if (c.scrollTopChanged) {
+                handleInput1OnScroll();
+            }
+            if (c.scrollLeftChanged) {
+                this.baseView.get()?.editor.setScrollLeft(c.scrollLeft, 1 );
+                this.input2View.editor.setScrollLeft(c.scrollLeft, 1 );
+                this.inputResultView.editor.setScrollLeft(c.scrollLeft, 1 );
+            }
+        })));
+        this._store.add(this.input2View.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
+            if (!this.model) {
+                return;
+            }
+            if (c.scrollTopChanged) {
+                this.input1View.editor.setScrollTop(c.scrollTop, 1 );
+                if (this.shouldAlignResult) {
+                    this.inputResultView.editor.setScrollTop(this.input2View.editor.getScrollTop(), 1 );
+                }
+                else {
+                    const mappingInput2Result = this.model.input2ResultMapping.get();
+                    this.synchronizeScrolling(this.input2View.editor, this.inputResultView.editor, mappingInput2Result);
+                }
+                const baseView = this.baseView.get();
+                if (baseView && this.model) {
+                    if (this.shouldAlignBase) {
+                        this.baseView.get()?.editor.setScrollTop(c.scrollTop, 1 );
+                    }
+                    else {
+                        const mapping = ( new DocumentLineRangeMap(this.model.baseInput2Diffs.get(), -1)).reverse();
+                        this.synchronizeScrolling(this.input2View.editor, baseView.editor, mapping);
+                    }
+                }
+            }
+            if (c.scrollLeftChanged) {
+                this.baseView.get()?.editor.setScrollLeft(c.scrollLeft, 1 );
+                this.input1View.editor.setScrollLeft(c.scrollLeft, 1 );
+                this.inputResultView.editor.setScrollLeft(c.scrollLeft, 1 );
+            }
+        })));
+        this._store.add(this.inputResultView.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
+            if (c.scrollTopChanged) {
+                if (this.shouldAlignResult) {
+                    this.input1View.editor.setScrollTop(c.scrollTop, 1 );
+                    this.input2View.editor.setScrollTop(c.scrollTop, 1 );
+                }
+                else {
+                    const mapping1 = this.model?.resultInput1Mapping.get();
+                    this.synchronizeScrolling(this.inputResultView.editor, this.input1View.editor, mapping1);
+                    const mapping2 = this.model?.resultInput2Mapping.get();
+                    this.synchronizeScrolling(this.inputResultView.editor, this.input2View.editor, mapping2);
+                }
+                const baseMapping = this.model?.resultBaseMapping.get();
+                const baseView = this.baseView.get();
+                if (baseView && this.model) {
+                    this.synchronizeScrolling(this.inputResultView.editor, baseView.editor, baseMapping);
+                }
+            }
+            if (c.scrollLeftChanged) {
+                this.baseView.get()?.editor?.setScrollLeft(c.scrollLeft, 1 );
+                this.input1View.editor.setScrollLeft(c.scrollLeft, 1 );
+                this.input2View.editor.setScrollLeft(c.scrollLeft, 1 );
+            }
+        })));
+        this._store.add(autorunWithStore((reader, store) => {
+            const baseView = this.baseView.read(reader);
+            if (baseView) {
+                store.add(baseView.editor.onDidScrollChange(this.reentrancyBarrier.makeExclusive((c) => {
+                    if (c.scrollTopChanged) {
+                        if (!this.model) {
+                            return;
+                        }
+                        if (this.shouldAlignBase) {
+                            this.input1View.editor.setScrollTop(c.scrollTop, 1 );
+                            this.input2View.editor.setScrollTop(c.scrollTop, 1 );
+                        }
+                        else {
+                            const baseInput1Mapping = ( new DocumentLineRangeMap(this.model.baseInput1Diffs.get(), -1));
+                            this.synchronizeScrolling(baseView.editor, this.input1View.editor, baseInput1Mapping);
+                            const baseInput2Mapping = ( new DocumentLineRangeMap(this.model.baseInput2Diffs.get(), -1));
+                            this.synchronizeScrolling(baseView.editor, this.input2View.editor, baseInput2Mapping);
+                        }
+                        const baseMapping = this.model?.baseResultMapping.get();
+                        this.synchronizeScrolling(baseView.editor, this.inputResultView.editor, baseMapping);
+                    }
+                    if (c.scrollLeftChanged) {
+                        this.inputResultView.editor.setScrollLeft(c.scrollLeft, 1 );
+                        this.input1View.editor.setScrollLeft(c.scrollLeft, 1 );
+                        this.input2View.editor.setScrollLeft(c.scrollLeft, 1 );
+                    }
+                })));
+            }
+        }));
+    }
+    synchronizeScrolling(scrollingEditor, targetEditor, mapping) {
+        if (!mapping) {
+            return;
+        }
+        const visibleRanges = scrollingEditor.getVisibleRanges();
+        if (visibleRanges.length === 0) {
+            return;
+        }
+        const topLineNumber = visibleRanges[0].startLineNumber - 1;
+        const result = mapping.project(topLineNumber);
+        const sourceRange = result.inputRange;
+        const targetRange = result.outputRange;
+        const resultStartTopPx = targetEditor.getTopForLineNumber(targetRange.startLineNumber);
+        const resultEndPx = targetEditor.getTopForLineNumber(targetRange.endLineNumberExclusive);
+        const sourceStartTopPx = scrollingEditor.getTopForLineNumber(sourceRange.startLineNumber);
+        const sourceEndPx = scrollingEditor.getTopForLineNumber(sourceRange.endLineNumberExclusive);
+        const factor = Math.min((scrollingEditor.getScrollTop() - sourceStartTopPx) / (sourceEndPx - sourceStartTopPx), 1);
+        const resultScrollPosition = resultStartTopPx + (resultEndPx - resultStartTopPx) * factor;
+        targetEditor.setScrollTop(resultScrollPosition, 1 );
+    }
+}
+export { ScrollSynchronizer };

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

@@ -0,0 +1,262 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { findLast } from '../../../../../base/common/arraysFind.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.js';
+import { LineRange } from '../model/lineRange.js';
+import { observableConfigValue } from '../utils.js';
+import { observableValue, transaction } from '../../../../../base/common/observableInternal/base.js';
+import { derivedObservableWithWritableCache } from '../../../../../base/common/observableInternal/utils.js';
+import { derived } from '../../../../../base/common/observableInternal/derived.js';
+let MergeEditorViewModel = class MergeEditorViewModel extends Disposable {
+    constructor(model, inputCodeEditorView1, inputCodeEditorView2, resultCodeEditorView, baseCodeEditorView, showNonConflictingChanges, configurationService, notificationService) {
+        super();
+        this.model = model;
+        this.inputCodeEditorView1 = inputCodeEditorView1;
+        this.inputCodeEditorView2 = inputCodeEditorView2;
+        this.resultCodeEditorView = resultCodeEditorView;
+        this.baseCodeEditorView = baseCodeEditorView;
+        this.showNonConflictingChanges = showNonConflictingChanges;
+        this.configurationService = configurationService;
+        this.notificationService = notificationService;
+        this.manuallySetActiveModifiedBaseRange = observableValue(this, { range: undefined, counter: 0 });
+        this.attachedHistory = this._register(( new AttachedHistory(this.model.resultTextModel)));
+        this.shouldUseAppendInsteadOfAccept = observableConfigValue('mergeEditor.shouldUseAppendInsteadOfAccept', false, this.configurationService);
+        this.counter = 0;
+        this.lastFocusedEditor = derivedObservableWithWritableCache(this, (reader, lastValue) => {
+            const editors = [
+                this.inputCodeEditorView1,
+                this.inputCodeEditorView2,
+                this.resultCodeEditorView,
+                this.baseCodeEditorView.read(reader),
+            ];
+            const view = editors.find((e) => e && e.isFocused.read(reader));
+            return view ? { view, counter: this.counter++ } : lastValue || { view: undefined, counter: this.counter++ };
+        });
+        this.baseShowDiffAgainst = derived(this, reader => {
+            const lastFocusedEditor = this.lastFocusedEditor.read(reader);
+            if (lastFocusedEditor.view === this.inputCodeEditorView1) {
+                return 1;
+            }
+            else if (lastFocusedEditor.view === this.inputCodeEditorView2) {
+                return 2;
+            }
+            return undefined;
+        });
+        this.selectionInBase = derived(this, reader => {
+            const sourceEditor = this.lastFocusedEditor.read(reader).view;
+            if (!sourceEditor) {
+                return undefined;
+            }
+            const selections = sourceEditor.selection.read(reader) || [];
+            const rangesInBase = ( selections.map((selection) => {
+                if (sourceEditor === this.inputCodeEditorView1) {
+                    return this.model.translateInputRangeToBase(1, selection);
+                }
+                else if (sourceEditor === this.inputCodeEditorView2) {
+                    return this.model.translateInputRangeToBase(2, selection);
+                }
+                else if (sourceEditor === this.resultCodeEditorView) {
+                    return this.model.translateResultRangeToBase(selection);
+                }
+                else if (sourceEditor === this.baseCodeEditorView.read(reader)) {
+                    return selection;
+                }
+                else {
+                    return selection;
+                }
+            }));
+            return {
+                rangesInBase,
+                sourceEditor
+            };
+        });
+        this.activeModifiedBaseRange = derived(this, (reader) => {
+            const focusedEditor = this.lastFocusedEditor.read(reader);
+            const manualRange = this.manuallySetActiveModifiedBaseRange.read(reader);
+            if (manualRange.counter > focusedEditor.counter) {
+                return manualRange.range;
+            }
+            if (!focusedEditor.view) {
+                return;
+            }
+            const cursorLineNumber = focusedEditor.view.cursorLineNumber.read(reader);
+            if (!cursorLineNumber) {
+                return undefined;
+            }
+            const modifiedBaseRanges = this.model.modifiedBaseRanges.read(reader);
+            return modifiedBaseRanges.find((r) => {
+                const range = this.getRangeOfModifiedBaseRange(focusedEditor.view, r, reader);
+                return range.isEmpty
+                    ? range.startLineNumber === cursorLineNumber
+                    : range.contains(cursorLineNumber);
+            });
+        });
+        this._register(resultCodeEditorView.editor.onDidChangeModelContent(e => {
+            if (this.model.isApplyingEditInResult || e.isRedoing || e.isUndoing) {
+                return;
+            }
+            const baseRangeStates = [];
+            for (const change of e.changes) {
+                const rangeInBase = this.model.translateResultRangeToBase(Range.lift(change.range));
+                const baseRanges = this.model.findModifiedBaseRangesInRange(( new LineRange(
+                    rangeInBase.startLineNumber,
+                    rangeInBase.endLineNumber - rangeInBase.startLineNumber
+                )));
+                if (baseRanges.length === 1) {
+                    const isHandled = this.model.isHandled(baseRanges[0]).get();
+                    if (!isHandled) {
+                        baseRangeStates.push(baseRanges[0]);
+                    }
+                }
+            }
+            if (baseRangeStates.length === 0) {
+                return;
+            }
+            const element = {
+                model: this.model,
+                redo() {
+                    transaction(tx => {
+                        for (const r of baseRangeStates) {
+                            this.model.setHandled(r, true, tx);
+                        }
+                    });
+                },
+                undo() {
+                    transaction(tx => {
+                        for (const r of baseRangeStates) {
+                            this.model.setHandled(r, false, tx);
+                        }
+                    });
+                },
+            };
+            this.attachedHistory.pushAttachedHistoryElement(element);
+            element.redo();
+        }));
+    }
+    getRangeOfModifiedBaseRange(editor, modifiedBaseRange, reader) {
+        if (editor === this.resultCodeEditorView) {
+            return this.model.getLineRangeInResult(modifiedBaseRange.baseRange, reader);
+        }
+        else if (editor === this.baseCodeEditorView.get()) {
+            return modifiedBaseRange.baseRange;
+        }
+        else {
+            const input = editor === this.inputCodeEditorView1 ? 1 : 2;
+            return modifiedBaseRange.getInputRange(input);
+        }
+    }
+    setActiveModifiedBaseRange(range, tx) {
+        this.manuallySetActiveModifiedBaseRange.set({ range, counter: this.counter++ }, tx);
+    }
+    setState(baseRange, state, tx, inputNumber) {
+        this.manuallySetActiveModifiedBaseRange.set({ range: baseRange, counter: this.counter++ }, tx);
+        this.model.setState(baseRange, state, inputNumber, tx);
+    }
+    goToConflict(getModifiedBaseRange) {
+        let editor = this.lastFocusedEditor.get().view;
+        if (!editor) {
+            editor = this.resultCodeEditorView;
+        }
+        const curLineNumber = editor.editor.getPosition()?.lineNumber;
+        if (curLineNumber === undefined) {
+            return;
+        }
+        const modifiedBaseRange = getModifiedBaseRange(editor, curLineNumber);
+        if (modifiedBaseRange) {
+            const range = this.getRangeOfModifiedBaseRange(editor, modifiedBaseRange, undefined);
+            editor.editor.focus();
+            let startLineNumber = range.startLineNumber;
+            let endLineNumberExclusive = range.endLineNumberExclusive;
+            if (range.startLineNumber > editor.editor.getModel().getLineCount()) {
+                transaction(tx => {
+                    this.setActiveModifiedBaseRange(modifiedBaseRange, tx);
+                });
+                startLineNumber = endLineNumberExclusive = editor.editor.getModel().getLineCount();
+            }
+            editor.editor.setPosition({
+                lineNumber: startLineNumber,
+                column: editor.editor.getModel().getLineFirstNonWhitespaceColumn(startLineNumber),
+            });
+            editor.editor.revealLinesNearTop(startLineNumber, endLineNumberExclusive, 0 );
+        }
+    }
+    goToNextModifiedBaseRange(predicate) {
+        this.goToConflict((e, l) => this.model.modifiedBaseRanges
+            .get()
+            .find((r) => predicate(r) &&
+            this.getRangeOfModifiedBaseRange(e, r, undefined).startLineNumber > l) ||
+            this.model.modifiedBaseRanges
+                .get()
+                .find((r) => predicate(r)));
+    }
+    goToPreviousModifiedBaseRange(predicate) {
+        this.goToConflict((e, l) => findLast(this.model.modifiedBaseRanges.get(), (r) => predicate(r) &&
+            this.getRangeOfModifiedBaseRange(e, r, undefined).endLineNumberExclusive < l) ||
+            findLast(this.model.modifiedBaseRanges.get(), (r) => predicate(r)));
+    }
+    toggleActiveConflict(inputNumber) {
+        const activeModifiedBaseRange = this.activeModifiedBaseRange.get();
+        if (!activeModifiedBaseRange) {
+            this.notificationService.error(( localizeWithPath(
+                'vs/workbench/contrib/mergeEditor/browser/view/viewModel',
+                'noConflictMessage',
+                "There is currently no conflict focused that can be toggled."
+            )));
+            return;
+        }
+        transaction(tx => {
+            this.setState(activeModifiedBaseRange, this.model.getState(activeModifiedBaseRange).get().toggle(inputNumber), tx, inputNumber);
+        });
+    }
+    acceptAll(inputNumber) {
+        transaction(tx => {
+            for (const range of this.model.modifiedBaseRanges.get()) {
+                this.setState(range, this.model.getState(range).get().withInputValue(inputNumber, true), tx, inputNumber);
+            }
+        });
+    }
+};
+MergeEditorViewModel = ( __decorate([
+    ( __param(6, IConfigurationService)),
+    ( __param(7, INotificationService))
+], MergeEditorViewModel));
+class AttachedHistory extends Disposable {
+    constructor(model) {
+        super();
+        this.model = model;
+        this.attachedHistory = [];
+        this.previousAltId = this.model.getAlternativeVersionId();
+        this._register(model.onDidChangeContent((e) => {
+            const currentAltId = model.getAlternativeVersionId();
+            if (e.isRedoing) {
+                for (const item of this.attachedHistory) {
+                    if (this.previousAltId < item.altId && item.altId <= currentAltId) {
+                        item.element.redo();
+                    }
+                }
+            }
+            else if (e.isUndoing) {
+                for (let i = this.attachedHistory.length - 1; i >= 0; i--) {
+                    const item = this.attachedHistory[i];
+                    if (currentAltId < item.altId && item.altId <= this.previousAltId) {
+                        item.element.undo();
+                    }
+                }
+            }
+            else {
+                while (this.attachedHistory.length > 0
+                    && this.attachedHistory[this.attachedHistory.length - 1].altId > this.previousAltId) {
+                    this.attachedHistory.pop();
+                }
+            }
+            this.previousAltId = currentAltId;
+        }));
+    }
+    pushAttachedHistoryElement(element) {
+        this.attachedHistory.push({ altId: this.model.getAlternativeVersionId(), element });
+    }
+}
+export { MergeEditorViewModel };

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

@@ -0,0 +1,171 @@
+import { $ } from '../../../../../base/browser/dom.js';
+import { CompareResult, lastOrDefault } from '../../../../../base/common/arrays.js';
+import { LineRange } from '../model/lineRange.js';
+import { join } from '../utils.js';
+import { ConflictActionsFactory, ActionsSource } from './conflictActions.js';
+import { getAlignments } from './lineAlignment.js';
+class ViewZoneComputer {
+    constructor(input1Editor, input2Editor, resultEditor) {
+        this.input1Editor = input1Editor;
+        this.input2Editor = input2Editor;
+        this.resultEditor = resultEditor;
+        this.conflictActionsFactoryInput1 = ( new ConflictActionsFactory(this.input1Editor));
+        this.conflictActionsFactoryInput2 = ( new ConflictActionsFactory(this.input2Editor));
+        this.conflictActionsFactoryResult = ( new ConflictActionsFactory(this.resultEditor));
+    }
+    computeViewZones(reader, viewModel, options) {
+        let input1LinesAdded = 0;
+        let input2LinesAdded = 0;
+        let baseLinesAdded = 0;
+        let resultLinesAdded = 0;
+        const input1ViewZones = [];
+        const input2ViewZones = [];
+        const baseViewZones = [];
+        const resultViewZones = [];
+        const model = viewModel.model;
+        const resultDiffs = model.baseResultDiffs.read(reader);
+        const baseRangeWithStoreAndTouchingDiffs = join(model.modifiedBaseRanges.read(reader), resultDiffs, (baseRange, diff) => baseRange.baseRange.touches(diff.inputRange)
+            ? CompareResult.neitherLessOrGreaterThan
+            : LineRange.compareByStart(baseRange.baseRange, diff.inputRange));
+        const shouldShowCodeLenses = options.codeLensesVisible;
+        const showNonConflictingChanges = options.showNonConflictingChanges;
+        let lastModifiedBaseRange = undefined;
+        let lastBaseResultDiff = undefined;
+        for (const m of baseRangeWithStoreAndTouchingDiffs) {
+            if (shouldShowCodeLenses && m.left && (m.left.isConflicting || showNonConflictingChanges || !model.isHandled(m.left).read(reader))) {
+                const actions = ( new ActionsSource(viewModel, m.left));
+                if (options.shouldAlignResult || !actions.inputIsEmpty.read(reader)) {
+                    input1ViewZones.push(( new CommandViewZone(
+                        this.conflictActionsFactoryInput1,
+                        m.left.input1Range.startLineNumber - 1,
+                        actions.itemsInput1
+                    )));
+                    input2ViewZones.push(( new CommandViewZone(
+                        this.conflictActionsFactoryInput2,
+                        m.left.input2Range.startLineNumber - 1,
+                        actions.itemsInput2
+                    )));
+                    if (options.shouldAlignBase) {
+                        baseViewZones.push(( new Placeholder(m.left.baseRange.startLineNumber - 1, 16)));
+                    }
+                }
+                const afterLineNumber = m.left.baseRange.startLineNumber + (lastBaseResultDiff?.resultingDeltaFromOriginalToModified ?? 0) - 1;
+                resultViewZones.push(( new CommandViewZone(this.conflictActionsFactoryResult, afterLineNumber, actions.resultItems)));
+            }
+            const lastResultDiff = lastOrDefault(m.rights);
+            if (lastResultDiff) {
+                lastBaseResultDiff = lastResultDiff;
+            }
+            let alignedLines;
+            if (m.left) {
+                alignedLines = ( getAlignments(m.left).map(a => ({
+                    input1Line: a[0],
+                    baseLine: a[1],
+                    input2Line: a[2],
+                    resultLine: undefined,
+                })));
+                lastModifiedBaseRange = m.left;
+                alignedLines[alignedLines.length - 1].resultLine =
+                    m.left.baseRange.endLineNumberExclusive
+                        + (lastBaseResultDiff ? lastBaseResultDiff.resultingDeltaFromOriginalToModified : 0);
+            }
+            else {
+                alignedLines = [{
+                        baseLine: lastResultDiff.inputRange.endLineNumberExclusive,
+                        input1Line: lastResultDiff.inputRange.endLineNumberExclusive + (lastModifiedBaseRange ? (lastModifiedBaseRange.input1Range.endLineNumberExclusive - lastModifiedBaseRange.baseRange.endLineNumberExclusive) : 0),
+                        input2Line: lastResultDiff.inputRange.endLineNumberExclusive + (lastModifiedBaseRange ? (lastModifiedBaseRange.input2Range.endLineNumberExclusive - lastModifiedBaseRange.baseRange.endLineNumberExclusive) : 0),
+                        resultLine: lastResultDiff.outputRange.endLineNumberExclusive,
+                    }];
+            }
+            for (const { input1Line, baseLine, input2Line, resultLine } of alignedLines) {
+                if (!options.shouldAlignBase && (input1Line === undefined || input2Line === undefined)) {
+                    continue;
+                }
+                const input1Line_ = input1Line !== undefined ? input1Line + input1LinesAdded : -1;
+                const input2Line_ = input2Line !== undefined ? input2Line + input2LinesAdded : -1;
+                const baseLine_ = baseLine + baseLinesAdded;
+                const resultLine_ = resultLine !== undefined ? resultLine + resultLinesAdded : -1;
+                const max = Math.max(options.shouldAlignBase ? baseLine_ : 0, input1Line_, input2Line_, options.shouldAlignResult ? resultLine_ : 0);
+                if (input1Line !== undefined) {
+                    const diffInput1 = max - input1Line_;
+                    if (diffInput1 > 0) {
+                        input1ViewZones.push(( new Spacer(input1Line - 1, diffInput1)));
+                        input1LinesAdded += diffInput1;
+                    }
+                }
+                if (input2Line !== undefined) {
+                    const diffInput2 = max - input2Line_;
+                    if (diffInput2 > 0) {
+                        input2ViewZones.push(( new Spacer(input2Line - 1, diffInput2)));
+                        input2LinesAdded += diffInput2;
+                    }
+                }
+                if (options.shouldAlignBase) {
+                    const diffBase = max - baseLine_;
+                    if (diffBase > 0) {
+                        baseViewZones.push(( new Spacer(baseLine - 1, diffBase)));
+                        baseLinesAdded += diffBase;
+                    }
+                }
+                if (options.shouldAlignResult && resultLine !== undefined) {
+                    const diffResult = max - resultLine_;
+                    if (diffResult > 0) {
+                        resultViewZones.push(( new Spacer(resultLine - 1, diffResult)));
+                        resultLinesAdded += diffResult;
+                    }
+                }
+            }
+        }
+        return ( new MergeEditorViewZones(input1ViewZones, input2ViewZones, baseViewZones, resultViewZones));
+    }
+}
+class MergeEditorViewZones {
+    constructor(input1ViewZones, input2ViewZones, baseViewZones, resultViewZones) {
+        this.input1ViewZones = input1ViewZones;
+        this.input2ViewZones = input2ViewZones;
+        this.baseViewZones = baseViewZones;
+        this.resultViewZones = resultViewZones;
+    }
+}
+class MergeEditorViewZone {
+}
+class Spacer extends MergeEditorViewZone {
+    constructor(afterLineNumber, heightInLines) {
+        super();
+        this.afterLineNumber = afterLineNumber;
+        this.heightInLines = heightInLines;
+    }
+    create(viewZoneChangeAccessor, viewZoneIdsToCleanUp, disposableStore) {
+        viewZoneIdsToCleanUp.push(viewZoneChangeAccessor.addZone({
+            afterLineNumber: this.afterLineNumber,
+            heightInLines: this.heightInLines,
+            domNode: $('div.diagonal-fill'),
+        }));
+    }
+}
+class Placeholder extends MergeEditorViewZone {
+    constructor(afterLineNumber, heightPx) {
+        super();
+        this.afterLineNumber = afterLineNumber;
+        this.heightPx = heightPx;
+    }
+    create(viewZoneChangeAccessor, viewZoneIdsToCleanUp, disposableStore) {
+        viewZoneIdsToCleanUp.push(viewZoneChangeAccessor.addZone({
+            afterLineNumber: this.afterLineNumber,
+            heightInPx: this.heightPx,
+            domNode: $('div.conflict-actions-placeholder'),
+        }));
+    }
+}
+class CommandViewZone extends MergeEditorViewZone {
+    constructor(conflictActionsFactory, lineNumber, items) {
+        super();
+        this.conflictActionsFactory = conflictActionsFactory;
+        this.lineNumber = lineNumber;
+        this.items = items;
+    }
+    create(viewZoneChangeAccessor, viewZoneIdsToCleanUp, disposableStore) {
+        disposableStore.add(this.conflictActionsFactory.createWidget(viewZoneChangeAccessor, this.lineNumber, this.items, viewZoneIdsToCleanUp));
+    }
+}
+export { MergeEditorViewZone, MergeEditorViewZones, ViewZoneComputer };

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.js

@@ -0,0 +1,41 @@
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event } from '../../../../base/common/event.js';
+import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+const IMultiDiffSourceResolverService = ( createDecorator('multiDiffSourceResolverService'));
+class ConstResolvedMultiDiffSource {
+    constructor(resources) {
+        this.resources = resources;
+        this.onDidChange = Event.None;
+    }
+}
+class MultiDiffEditorItem {
+    constructor(original, modified) {
+        this.original = original;
+        this.modified = modified;
+        if (!original && !modified) {
+            throw new BugIndicatingError('Invalid arguments');
+        }
+    }
+}
+class MultiDiffSourceResolverService {
+    constructor() {
+        this._resolvers = ( new Set());
+    }
+    registerResolver(resolver) {
+        if (( this._resolvers.has(resolver))) {
+            throw new BugIndicatingError('Duplicate resolver');
+        }
+        this._resolvers.add(resolver);
+        return toDisposable(() => this._resolvers.delete(resolver));
+    }
+    resolve(uri) {
+        for (const resolver of this._resolvers) {
+            if (resolver.canHandleUri(uri)) {
+                return resolver.resolveDiffSource(uri);
+            }
+        }
+        return Promise.resolve(undefined);
+    }
+}
+export { ConstResolvedMultiDiffSource, IMultiDiffSourceResolverService, MultiDiffEditorItem, MultiDiffSourceResolverService };