@codingame/monaco-vscode-multi-diff-editor-service-override 2.2.0-next.1

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from './multiDiffEditor.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './multiDiffEditor.js';

package/multiDiffEditor.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/multiDiffEditor.js

@@ -0,0 +1,11 @@
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IMultiDiffSourceResolverService, MultiDiffSourceResolverService } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
+import './vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditor.contribution.js';
+
+function getServiceOverride() {
+    return {
+        [( IMultiDiffSourceResolverService.toString())]: new SyncDescriptor(MultiDiffSourceResolverService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@codingame/monaco-vscode-multi-diff-editor-service-override",
+  "version": "2.2.0-next.1",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - multi-diff-editor service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@2.2.0-next.1",
+    "vscode-marked": "npm:marked@=3.0.2"
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Event } from 'vscode/vscode/vs/base/common/event';
+
+class ConstLazyPromise {
+    constructor(_value) {
+        this._value = _value;
+        this.onHasValueDidChange = Event.None;
+    }
+    request() {
+        return Promise.resolve(this._value);
+    }
+    get value() {
+        return this._value;
+    }
+}
+
+export { ConstLazyPromise };

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

@@ -0,0 +1,110 @@
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+import { Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { TextFileEditor } from 'vscode/vscode/vs/workbench/contrib/files/browser/editors/textFileEditor';
+import { MultiDiffEditor } from './multiDiffEditor.js';
+import { MultiDiffEditorInput } from './multiDiffEditorInput.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+class GoToFileAction extends Action2 {
+    constructor() {
+        super({
+            id: 'multiDiffEditor.goToFile',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/multiDiffEditor/browser/actions',
+                'goToFile',
+                'Open File'
+            )),
+            icon: Codicon.goToFile,
+            precondition: EditorContextKeys.inMultiDiffEditor,
+            menu: {
+                when: EditorContextKeys.inMultiDiffEditor,
+                id: MenuId.MultiDiffEditorFileToolbar,
+                order: 22,
+                group: 'navigation',
+            },
+        });
+    }
+    async run(accessor, ...args) {
+        const uri = args[0];
+        const editorService = accessor.get(IEditorService);
+        const activeEditorPane = editorService.activeEditorPane;
+        let selections = undefined;
+        if (activeEditorPane instanceof MultiDiffEditor) {
+            const editor = activeEditorPane.tryGetCodeEditor(uri);
+            if (editor) {
+                selections = editor.editor.getSelections() ?? undefined;
+            }
+        }
+        const editor = await editorService.openEditor({ resource: uri });
+        if (selections && (editor instanceof TextFileEditor)) {
+            const c = editor.getControl();
+            if (c) {
+                c.setSelections(selections);
+                c.revealLineInCenter(selections[0].selectionStartLineNumber);
+            }
+        }
+    }
+}
+class CollapseAllAction extends Action2 {
+    constructor() {
+        super({
+            id: 'multiDiffEditor.collapseAll',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/multiDiffEditor/browser/actions',
+                'collapseAllDiffs',
+                'Collapse All Diffs'
+            )),
+            icon: Codicon.collapseAll,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', MultiDiffEditor.ID)), ContextKeyExpr.not('multiDiffEditorAllCollapsed'))),
+            menu: {
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', MultiDiffEditor.ID)), ContextKeyExpr.not('multiDiffEditorAllCollapsed'))),
+                id: MenuId.EditorTitle,
+                group: 'navigation',
+                order: 100
+            },
+            f1: true,
+        });
+    }
+    async run(accessor, ...args) {
+        const editorService = accessor.get(IEditorService);
+        const activeEditor = editorService.activeEditor;
+        if (activeEditor instanceof MultiDiffEditorInput) {
+            const viewModel = await activeEditor.getViewModel();
+            viewModel.collapseAll();
+        }
+    }
+}
+class ExpandAllAction extends Action2 {
+    constructor() {
+        super({
+            id: 'multiDiffEditor.expandAll',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/multiDiffEditor/browser/actions',
+                'ExpandAllDiffs',
+                'Expand All Diffs'
+            )),
+            icon: Codicon.expandAll,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', MultiDiffEditor.ID)), ( ContextKeyExpr.has('multiDiffEditorAllCollapsed')))),
+            menu: {
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', MultiDiffEditor.ID)), ( ContextKeyExpr.has('multiDiffEditorAllCollapsed')))),
+                id: MenuId.EditorTitle,
+                group: 'navigation',
+                order: 100
+            },
+            f1: true,
+        });
+    }
+    async run(accessor, ...args) {
+        const editorService = accessor.get(IEditorService);
+        const activeEditor = editorService.activeEditor;
+        if (activeEditor instanceof MultiDiffEditorInput) {
+            const viewModel = await activeEditor.getViewModel();
+            viewModel.expandAll();
+        }
+    }
+}
+
+export { CollapseAllAction, ExpandAllAction, GoToFileAction };

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/icons.contribution.js

@@ -0,0 +1,11 @@
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerIcon } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
+
+const MultiDiffEditorIcon = registerIcon('multi-diff-editor-label-icon', Codicon.diffMultiple, ( localizeWithPath(
+ 'vs/workbench/contrib/multiDiffEditor/browser/icons.contribution',
+ 'multiDiffEditorLabelIcon',
+ 'Icon of the multi diff editor label.'
+)));
+
+export { MultiDiffEditorIcon };

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

@@ -0,0 +1,39 @@
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { MultiDiffEditor } from './multiDiffEditor.js';
+import { MultiDiffEditorResolverContribution, MultiDiffEditorInput, MultiDiffEditorSerializer } from './multiDiffEditorInput.js';
+import { GoToFileAction, CollapseAllAction, ExpandAllAction } from './actions.js';
+import { OpenScmGroupAction, ScmMultiDiffSourceResolverContribution } from './scmMultiDiffSourceResolver.js';
+
+registerAction2(GoToFileAction);
+registerAction2(CollapseAllAction);
+registerAction2(ExpandAllAction);
+( Registry.as(Extensions.Configuration))
+    .registerConfiguration({
+    properties: {
+        'multiDiffEditor.experimental.enabled': {
+            type: 'boolean',
+            default: true,
+            description: 'Enable experimental multi diff editor.',
+        },
+    }
+});
+( Registry.as(Extensions$1.Workbench))
+    .registerWorkbenchContribution(MultiDiffEditorResolverContribution, 1 );
+( Registry.as(EditorExtensions.EditorPane))
+    .registerEditorPane(EditorPaneDescriptor.create(MultiDiffEditor, MultiDiffEditor.ID, ( localizeWithPath(
+    'vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditor.contribution',
+    'name',
+    "Multi Diff Editor"
+))), [( new SyncDescriptor(MultiDiffEditorInput))]);
+( Registry.as(EditorExtensions.EditorFactory))
+    .registerEditorSerializer(MultiDiffEditorInput.ID, MultiDiffEditorSerializer);
+registerAction2(OpenScmGroupAction);
+( Registry.as(Extensions$1.Workbench))
+    .registerWorkbenchContribution(ScmMultiDiffSourceResolverContribution, 1 );

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

@@ -0,0 +1,97 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { MultiDiffEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/multiDiffEditorWidget/multiDiffEditorWidget';
+import { ITextResourceConfigurationService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { ResourceLabel } from 'vscode/vscode/vs/workbench/browser/labels';
+import { AbstractEditorWithViewState } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorWithViewState';
+import { MultiDiffEditorInput } from './multiDiffEditorInput.js';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+var MultiDiffEditor_1;
+let MultiDiffEditor = class MultiDiffEditor extends AbstractEditorWithViewState {
+    static { MultiDiffEditor_1 = this; }
+    static { this.ID = 'multiDiffEditor'; }
+    get viewModel() {
+        return this._viewModel;
+    }
+    constructor(instantiationService, telemetryService, themeService, storageService, editorService, editorGroupService, textResourceConfigurationService) {
+        super(MultiDiffEditor_1.ID, 'multiDiffEditor', telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService);
+        this._multiDiffEditorWidget = undefined;
+    }
+    createEditor(parent) {
+        this._multiDiffEditorWidget = this._register(this.instantiationService.createInstance(MultiDiffEditorWidget, parent, this.instantiationService.createInstance(WorkbenchUIElementFactory)));
+        this._register(this._multiDiffEditorWidget.onDidChangeActiveControl(() => {
+            this._onDidChangeControl.fire();
+        }));
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        this._viewModel = await input.getViewModel();
+        this._multiDiffEditorWidget.setViewModel(this._viewModel);
+        const viewState = this.loadEditorViewState(input, context);
+        if (viewState) {
+            this._multiDiffEditorWidget.setViewState(viewState);
+        }
+    }
+    async clearInput() {
+        await super.clearInput();
+        this._multiDiffEditorWidget.setViewModel(undefined);
+    }
+    layout(dimension) {
+        this._multiDiffEditorWidget.layout(dimension);
+    }
+    getControl() {
+        return this._multiDiffEditorWidget.getActiveControl();
+    }
+    computeEditorViewState(resource) {
+        return this._multiDiffEditorWidget.getViewState();
+    }
+    tracksEditorViewState(input) {
+        return input instanceof MultiDiffEditorInput;
+    }
+    toEditorViewStateResource(input) {
+        return input.resource;
+    }
+    tryGetCodeEditor(resource) {
+        return this._multiDiffEditorWidget.tryGetCodeEditor(resource);
+    }
+};
+MultiDiffEditor = MultiDiffEditor_1 = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IEditorGroupsService)),
+    ( __param(6, ITextResourceConfigurationService))
+], MultiDiffEditor));
+let WorkbenchUIElementFactory = class WorkbenchUIElementFactory {
+    constructor(_instantiationService) {
+        this._instantiationService = _instantiationService;
+    }
+    createResourceLabel(element) {
+        const label = this._instantiationService.createInstance(ResourceLabel, element, {});
+        return {
+            setUri(uri, options = {}) {
+                if (!uri) {
+                    label.element.clear();
+                }
+                else {
+                    label.element.setFile(uri, { strikethrough: options.strikethrough });
+                }
+            },
+            dispose() {
+                label.dispose();
+            }
+        };
+    }
+};
+WorkbenchUIElementFactory = ( __decorate([
+    ( __param(0, IInstantiationService))
+], WorkbenchUIElementFactory));
+
+export { MultiDiffEditor };

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

@@ -0,0 +1,302 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { LazyStatefulPromise, raceTimeout } from 'vscode/vscode/vs/base/common/async';
+import { BugIndicatingError, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore, toDisposable, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { parse } from 'vscode/vscode/vs/base/common/marshalling';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { deepClone } from 'vscode/vscode/vs/base/common/objects';
+import { observableFromEvent, constObservable, mapObservableArrayCached } from 'vscode/vscode/vs/base/common/observableInternal/utils';
+import { isDefined, isObject } from 'vscode/vscode/vs/base/common/types';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ConstLazyPromise } from '../../../../editor/browser/widget/multiDiffEditorWidget/model.js';
+import { MultiDiffEditorViewModel } from 'vscode/vscode/vs/editor/browser/widget/multiDiffEditorWidget/multiDiffEditorViewModel';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { ITextResourceConfigurationService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { DEFAULT_EDITOR_ASSOCIATION } from 'vscode/vscode/vs/workbench/common/editor';
+import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
+import { MultiDiffEditorIcon } from './icons.contribution.js';
+import { MultiDiffEditorItem, ConstResolvedMultiDiffSource, IMultiDiffSourceResolverService } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
+import { ObservableLazyStatefulPromise } from './utils.js';
+import { RegisteredEditorPriority, IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
+
+var MultiDiffEditorInput_1;
+let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
+    static { MultiDiffEditorInput_1 = this; }
+    static fromResourceMultiDiffEditorInput(input, instantiationService) {
+        if (!input.multiDiffSource && !input.resources) {
+            throw new BugIndicatingError('MultiDiffEditorInput requires either multiDiffSource or resources');
+        }
+        const multiDiffSource = input.multiDiffSource ?? ( URI.parse(`multi-diff-editor:${( ( new Date()).getMilliseconds().toString()) + ( Math.random().toString())}`));
+        return instantiationService.createInstance(MultiDiffEditorInput_1, multiDiffSource, input.label, input.resources?.map(resource => {
+            return ( new MultiDiffEditorItem(resource.original.resource, resource.modified.resource));
+        }));
+    }
+    static fromSerialized(data, instantiationService) {
+        return instantiationService.createInstance(MultiDiffEditorInput_1, ( URI.parse(data.multiDiffSourceUri)), data.label, data.resources?.map(resource => ( new MultiDiffEditorItem(resource.originalUri ? ( URI.parse(resource.originalUri)) : undefined, resource.modifiedUri ? ( URI.parse(resource.modifiedUri)) : undefined))));
+    }
+    static { this.ID = 'workbench.input.multiDiffEditor'; }
+    get resource() { return this.multiDiffSource; }
+    get capabilities() { return 2 ; }
+    get typeId() { return MultiDiffEditorInput_1.ID; }
+    getName() { return this._name; }
+    get editorId() { return DEFAULT_EDITOR_ASSOCIATION.id; }
+    getIcon() { return MultiDiffEditorIcon; }
+    constructor(multiDiffSource, label, initialResources, _textModelService, _textResourceConfigurationService, _instantiationService, _multiDiffSourceResolverService, _textFileService) {
+        super();
+        this.multiDiffSource = multiDiffSource;
+        this.label = label;
+        this.initialResources = initialResources;
+        this._textModelService = _textModelService;
+        this._textResourceConfigurationService = _textResourceConfigurationService;
+        this._instantiationService = _instantiationService;
+        this._multiDiffSourceResolverService = _multiDiffSourceResolverService;
+        this._textFileService = _textFileService;
+        this._name = '';
+        this._viewModel = ( new LazyStatefulPromise(async () => {
+            const model = await this._createModel();
+            this._register(model);
+            const vm = ( new MultiDiffEditorViewModel(model, this._instantiationService));
+            this._register(vm);
+            await raceTimeout(vm.waitForDiffs(), 1000);
+            return vm;
+        }));
+        this._resolvedSource = ( new ObservableLazyStatefulPromise(async () => {
+            const source = this.initialResources
+                ? ( new ConstResolvedMultiDiffSource(this.initialResources))
+                : await this._multiDiffSourceResolverService.resolve(this.multiDiffSource);
+            return {
+                source,
+                resources: source ? observableFromEvent(source.onDidChange, () => source.resources) : constObservable([]),
+            };
+        }));
+        this._resources = derived(this, reader => this._resolvedSource.cachedValue.read(reader)?.value?.resources.read(reader));
+        this._isDirtyObservables = mapObservableArrayCached(this, ( this._resources.map(r => r || [])), res => {
+            const isModifiedDirty = res.modified ? isUriDirty(this._textFileService, res.modified) : constObservable(false);
+            const isOriginalDirty = res.original ? isUriDirty(this._textFileService, res.original) : constObservable(false);
+            return derived(reader =>  isModifiedDirty.read(reader) || isOriginalDirty.read(reader));
+        }, i => JSON.stringify([i.modified?.toString(), i.original?.toString()]));
+        this._isDirtyObservable = derived(this, reader => ( this._isDirtyObservables.read(reader).some(isDirty => isDirty.read(reader))))
+            .keepObserved(this._store);
+        this.onDidChangeDirty = Event.fromObservableLight(this._isDirtyObservable);
+        this.closeHandler = {
+            async confirm() {
+                return 1 ;
+            },
+            showConfirm() {
+                return false;
+            }
+        };
+        this._register(autorun((reader) => {
+            const resources = this._resources.read(reader) ?? [];
+            const label = this.label ?? ( localizeWithPath(
+                'vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput',
+                'name',
+                "Multi Diff Editor"
+            ));
+            this._name = label + ( localizeWithPath(
+                'vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput',
+                'files',
+                " ({0} files)",
+                resources?.length ?? 0
+            ));
+            this._onDidChangeLabel.fire();
+        }));
+    }
+    serialize() {
+        return {
+            label: this.label,
+            multiDiffSourceUri: ( this.multiDiffSource.toString()),
+            resources: this.initialResources?.map(resource => ({
+                originalUri: resource.original?.toString(),
+                modifiedUri: resource.modified?.toString(),
+            })),
+        };
+    }
+    setLanguageId(languageId, source) {
+        const activeDiffItem = this._viewModel.requireValue().activeDiffItem.get();
+        const value = activeDiffItem?.entry?.value;
+        if (!value) {
+            return;
+        }
+        const target = value.modified ?? value.original;
+        if (!target) {
+            return;
+        }
+        target.setLanguage(languageId, source);
+    }
+    async getViewModel() {
+        return this._viewModel.getPromise();
+    }
+    async _createModel() {
+        const source = await this._resolvedSource.getValue();
+        const textResourceConfigurationService = this._textResourceConfigurationService;
+        const garbage = ( new DisposableStore());
+        const documentsWithPromises = mapObservableArrayCached(undefined, source.resources, async (r, store) => {
+            let original;
+            let modified;
+            const store2 = ( new DisposableStore());
+            store.add(toDisposable(() => {
+                garbage.add(store2);
+            }));
+            try {
+                [original, modified] = await Promise.all([
+                    r.original ? this._textModelService.createModelReference(r.original) : undefined,
+                    r.modified ? this._textModelService.createModelReference(r.modified) : undefined,
+                ]);
+                if (original) {
+                    store.add(original);
+                }
+                if (modified) {
+                    store.add(modified);
+                }
+            }
+            catch (e) {
+                console.error(e);
+                onUnexpectedError(e);
+                return undefined;
+            }
+            const uri = (r.modified ?? r.original);
+            return ( new ConstLazyPromise({
+                original: original?.object.textEditorModel,
+                modified: modified?.object.textEditorModel,
+                get options() {
+                    return {
+                        ...getReadonlyConfiguration(modified?.object.isReadonly() ?? true),
+                        ...computeOptions(textResourceConfigurationService.getValue(uri)),
+                    };
+                },
+                onOptionsDidChange: h => this._textResourceConfigurationService.onDidChangeConfiguration(e => {
+                    if (e.affectsConfiguration(uri, 'editor') || e.affectsConfiguration(uri, 'diffEditor')) {
+                        h();
+                    }
+                }),
+            }));
+        }, i => JSON.stringify([i.modified?.toString(), i.original?.toString()]));
+        let documents = [];
+        const documentChangeEmitter = ( new Emitter());
+        const p = Event.toPromise(documentChangeEmitter.event);
+        const a = autorun(async (reader) => {
+            const docsPromises = documentsWithPromises.read(reader);
+            const docs = await Promise.all(docsPromises);
+            documents = docs.filter(isDefined);
+            documentChangeEmitter.fire();
+            garbage.clear();
+        });
+        await p;
+        return {
+            dispose: () => {
+                a.dispose();
+                garbage.dispose();
+            },
+            onDidChange: documentChangeEmitter.event,
+            get documents() { return documents; },
+            contextKeys: source.source?.contextKeys,
+        };
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof MultiDiffEditorInput_1) {
+            return ( this.multiDiffSource.toString()) === ( otherInput.multiDiffSource.toString());
+        }
+        return false;
+    }
+    isDirty() { return this._isDirtyObservable.get(); }
+    async save(group, options) {
+        await this.doSaveOrRevert('save', group, options);
+        return this;
+    }
+    revert(group, options) {
+        return this.doSaveOrRevert('revert', group, options);
+    }
+    async doSaveOrRevert(mode, group, options) {
+        const items = this._viewModel.currentValue?.items.get();
+        if (items) {
+            await Promise.all(( items.map(async (item) => {
+                const model = item.diffEditorViewModel.model;
+                const handleOriginal = model.original.uri.scheme !== Schemas.untitled && this._textFileService.isDirty(model.original.uri);
+                await Promise.all([
+                    handleOriginal ? mode === 'save' ? this._textFileService.save(model.original.uri, options) : this._textFileService.revert(model.original.uri, options) : Promise.resolve(),
+                    mode === 'save' ? this._textFileService.save(model.modified.uri, options) : this._textFileService.revert(model.modified.uri, options),
+                ]);
+            })));
+        }
+        return undefined;
+    }
+};
+MultiDiffEditorInput = MultiDiffEditorInput_1 = ( __decorate([
+    ( __param(3, ITextModelService)),
+    ( __param(4, ITextResourceConfigurationService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IMultiDiffSourceResolverService)),
+    ( __param(7, ITextFileService))
+], MultiDiffEditorInput));
+function isUriDirty(textFileService, uri) {
+    return observableFromEvent(Event.filter(textFileService.files.onDidChangeDirty, e => ( e.resource.toString()) === ( uri.toString())), () => textFileService.isDirty(uri));
+}
+function getReadonlyConfiguration(isReadonly) {
+    return {
+        readOnly: !!isReadonly,
+        readOnlyMessage: typeof isReadonly !== 'boolean' ? isReadonly : undefined
+    };
+}
+function computeOptions(configuration) {
+    const editorConfiguration = deepClone(configuration.editor);
+    if (isObject(configuration.diffEditor)) {
+        const diffEditorConfiguration = deepClone(configuration.diffEditor);
+        diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
+        delete diffEditorConfiguration.codeLens;
+        diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
+        delete diffEditorConfiguration.wordWrap;
+        Object.assign(editorConfiguration, diffEditorConfiguration);
+    }
+    return editorConfiguration;
+}
+let MultiDiffEditorResolverContribution = class MultiDiffEditorResolverContribution extends Disposable {
+    constructor(editorResolverService, instantiationService) {
+        super();
+        this._register(editorResolverService.registerEditor(`*`, {
+            id: DEFAULT_EDITOR_ASSOCIATION.id,
+            label: DEFAULT_EDITOR_ASSOCIATION.displayName,
+            detail: DEFAULT_EDITOR_ASSOCIATION.providerDisplayName,
+            priority: RegisteredEditorPriority.builtin
+        }, {}, {
+            createMultiDiffEditorInput: (diffListEditor) => {
+                return {
+                    editor: MultiDiffEditorInput.fromResourceMultiDiffEditorInput(diffListEditor, instantiationService),
+                };
+            },
+        }));
+    }
+};
+MultiDiffEditorResolverContribution = ( __decorate([
+    ( __param(0, IEditorResolverService)),
+    ( __param(1, IInstantiationService))
+], MultiDiffEditorResolverContribution));
+class MultiDiffEditorSerializer {
+    canSerialize(editor) {
+        return editor instanceof MultiDiffEditorInput;
+    }
+    serialize(editor) {
+        return JSON.stringify(editor.serialize());
+    }
+    deserialize(instantiationService, serializedEditor) {
+        try {
+            const data = parse(serializedEditor);
+            return MultiDiffEditorInput.fromSerialized(data, instantiationService);
+        }
+        catch (err) {
+            onUnexpectedError(err);
+            return undefined;
+        }
+    }
+}
+
+export { MultiDiffEditorInput, MultiDiffEditorResolverContribution, MultiDiffEditorSerializer };

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

@@ -0,0 +1,144 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IMultiDiffSourceResolverService } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
+import { ISCMService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
+
+var ScmMultiDiffSourceResolver_1;
+let ScmMultiDiffSourceResolver = class ScmMultiDiffSourceResolver {
+    static { ScmMultiDiffSourceResolver_1 = this; }
+    static { this._scheme = 'scm-multi-diff-source'; }
+    static getMultiDiffSourceUri(repositoryUri, groupId) {
+        return ( URI.from({
+            scheme: ScmMultiDiffSourceResolver_1._scheme,
+            query: JSON.stringify({ repositoryUri, groupId }),
+        }));
+    }
+    static parseUri(uri) {
+        if (uri.scheme !== ScmMultiDiffSourceResolver_1._scheme) {
+            return undefined;
+        }
+        let query;
+        try {
+            query = JSON.parse(uri.query);
+        }
+        catch (e) {
+            return undefined;
+        }
+        if (typeof query !== 'object' || query === null) {
+            return undefined;
+        }
+        const { repositoryUri, groupId } = query;
+        if (typeof repositoryUri !== 'string' || typeof groupId !== 'string') {
+            return undefined;
+        }
+        return { repositoryUri: ( URI.parse(repositoryUri)), groupId };
+    }
+    constructor(_scmService) {
+        this._scmService = _scmService;
+    }
+    canHandleUri(uri) {
+        return ScmMultiDiffSourceResolver_1.parseUri(uri) !== undefined;
+    }
+    async resolveDiffSource(uri) {
+        const { repositoryUri, groupId } = ScmMultiDiffSourceResolver_1.parseUri(uri);
+        const repository = await promiseFromEventState(this._scmService.onDidAddRepository, () => {
+            const repository = [...this._scmService.repositories].find(r => r.provider.rootUri?.toString() === ( repositoryUri.toString()));
+            return repository ?? false;
+        });
+        const group = await promiseFromEventState(repository.provider.onDidChangeResourceGroups, () => {
+            const group = repository.provider.groups.find(g => g.id === groupId);
+            return group ?? false;
+        });
+        const resources = observableFromEvent(group.onDidChangeResources, () => ( group.resources.map(e => {
+            return {
+                original: e.multiDiffEditorOriginalUri,
+                modified: e.multiDiffEditorModifiedUri
+            };
+        })));
+        return ( new ScmResolvedMultiDiffSource(resources, {
+            scmResourceGroup: groupId,
+            scmProvider: repository.provider.contextValue,
+        }));
+    }
+};
+ScmMultiDiffSourceResolver = ScmMultiDiffSourceResolver_1 = ( __decorate([
+    ( __param(0, ISCMService))
+], ScmMultiDiffSourceResolver));
+class ScmResolvedMultiDiffSource {
+    get resources() { return this._resources.get(); }
+    constructor(_resources, contextKeys) {
+        this._resources = _resources;
+        this.contextKeys = contextKeys;
+        this.onDidChange = Event.fromObservableLight(this._resources);
+    }
+}
+function promiseFromEventState(event, checkState) {
+    const state = checkState();
+    if (state) {
+        return Promise.resolve(state);
+    }
+    return ( new Promise(resolve => {
+        const listener = event(() => {
+            const state = checkState();
+            if (state) {
+                listener.dispose();
+                resolve(state);
+            }
+        });
+    }));
+}
+let ScmMultiDiffSourceResolverContribution = class ScmMultiDiffSourceResolverContribution extends Disposable {
+    constructor(instantiationService, multiDiffSourceResolverService) {
+        super();
+        this._register(multiDiffSourceResolverService.registerResolver(instantiationService.createInstance(ScmMultiDiffSourceResolver)));
+    }
+};
+ScmMultiDiffSourceResolverContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IMultiDiffSourceResolverService))
+], ScmMultiDiffSourceResolverContribution));
+class OpenScmGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: 'multiDiffEditor.openScmDiff',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/multiDiffEditor/browser/scmMultiDiffSourceResolver',
+                'viewChanges',
+                'View Changes'
+            )),
+            icon: Codicon.diffMultiple,
+            menu: {
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.has('config.multiDiffEditor.experimental.enabled')), ( ContextKeyExpr.has('multiDiffEditorEnableViewChanges')))),
+                id: MenuId.SCMResourceGroupContext,
+                group: 'inline',
+            },
+            f1: false,
+        });
+    }
+    async run(accessor, group) {
+        const editorService = accessor.get(IEditorService);
+        if (!group.provider.rootUri) {
+            return;
+        }
+        const multiDiffSource = ScmMultiDiffSourceResolver.getMultiDiffSourceUri(( group.provider.rootUri.toString()), group.id);
+        const label = ( localizeWithPath(
+            'vs/workbench/contrib/multiDiffEditor/browser/scmMultiDiffSourceResolver',
+            'scmDiffLabel',
+            '{0}: {1}',
+            group.provider.label,
+            group.label
+        ));
+        await editorService.openEditor({ label, multiDiffSource });
+    }
+}
+
+export { OpenScmGroupAction, ScmMultiDiffSourceResolver, ScmMultiDiffSourceResolverContribution };

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

@@ -0,0 +1,57 @@
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+
+class ObservableLazy {
+    get cachedValue() { return this._value; }
+    constructor(_computeValue) {
+        this._computeValue = _computeValue;
+        this._value = observableValue(this, undefined);
+    }
+    getValue() {
+        let v = this._value.get();
+        if (!v) {
+            v = this._computeValue();
+            this._value.set(v, undefined);
+        }
+        return v;
+    }
+}
+class ObservablePromise {
+    constructor(promise) {
+        this._value = observableValue(this, undefined);
+        this.value = this._value;
+        this.promise = promise.then(value => {
+            this._value.set(( new PromiseResult(value, undefined)), undefined);
+            return value;
+        }, error => {
+            this._value.set(( new PromiseResult(undefined, error)), undefined);
+            throw error;
+        });
+    }
+}
+class PromiseResult {
+    constructor(
+    value,
+    error) {
+        this.value = value;
+        this.error = error;
+    }
+    getValue() {
+        if (this.error) {
+            throw this.error;
+        }
+        return this.value;
+    }
+}
+class ObservableLazyStatefulPromise {
+    constructor(_computeValue) {
+        this._computeValue = _computeValue;
+        this._lazyValue = ( new ObservableLazy(() => ( new ObservablePromise(this._computeValue()))));
+        this.cachedValue = derived(this, reader => this._lazyValue.cachedValue.read(reader)?.value.read(reader));
+    }
+    getValue() {
+        return this._lazyValue.getValue().promise;
+    }
+}
+
+export { ObservableLazy, ObservableLazyStatefulPromise, ObservablePromise, PromiseResult };