@codingame/monaco-vscode-multi-diff-editor-service-override 4.1.0 → 4.1.2

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/multiDiffEditor.js

@@ -1,6 +1,6 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { IMultiDiffSourceResolverService, MultiDiffSourceResolverService } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
-import 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditor.contribution';
+import './vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditor.contribution.js';
 
 function getServiceOverride() {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-multi-diff-editor-service-override",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.2"
   }
 }

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 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+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/multiDiffEditor.contribution.js

@@ -0,0 +1,40 @@
+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 { registerWorkbenchContribution2 } 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 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { GoToFileAction, CollapseAllAction, ExpandAllAction } from './actions.js';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import 'vscode/vscode/vs/base/common/event';
+import 'vscode/vscode/vs/base/common/lifecycle';
+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.',
+        },
+    }
+});
+registerWorkbenchContribution2(MultiDiffEditorResolverContribution.ID, 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);
+registerWorkbenchContribution2(ScmMultiDiffSourceResolverContribution.ID, ScmMultiDiffSourceResolverContribution, 1 );

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

@@ -0,0 +1,119 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { MultiDiffEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/multiDiffEditor/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 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+
+var MultiDiffEditor_1;
+let MultiDiffEditor = class MultiDiffEditor extends AbstractEditorWithViewState {
+    static { MultiDiffEditor_1 = this; }
+    static { this.ID = 'multiDiffEditor'; }
+    get viewModel() {
+        return this._viewModel;
+    }
+    constructor(group, instantiationService, telemetryService, themeService, storageService, editorService, editorGroupService, textResourceConfigurationService) {
+        super(MultiDiffEditor_1.ID, group, '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);
+        }
+        this._applyOptions(options);
+    }
+    setOptions(options) {
+        this._applyOptions(options);
+    }
+    _applyOptions(options) {
+        const viewState = options?.viewState;
+        if (!viewState || !viewState.revealData) {
+            return;
+        }
+        this._multiDiffEditorWidget?.reveal(viewState.revealData.resource, {
+            range: viewState.revealData.range ? Range.lift(viewState.revealData.range) : undefined,
+            highlight: true
+        });
+    }
+    async clearInput() {
+        await super.clearInput();
+        this._multiDiffEditorWidget.setViewModel(undefined);
+    }
+    layout(dimension) {
+        this._multiDiffEditorWidget.layout(dimension);
+    }
+    getControl() {
+        return this._multiDiffEditorWidget.getActiveControl();
+    }
+    focus() {
+        super.focus();
+        this._multiDiffEditorWidget?.getActiveControl()?.focus();
+    }
+    hasFocus() {
+        return this._multiDiffEditorWidget?.getActiveControl()?.hasTextFocus() || super.hasFocus();
+    }
+    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(1, IInstantiationService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IThemeService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IEditorGroupsService)),
+    ( __param(7, 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/scmMultiDiffSourceResolver.js

@@ -0,0 +1,148 @@
+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 'vscode/vscode/vs/base/common/observableInternal/derived';
+import 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
+import 'vscode/vscode/vs/base/common/cancellation';
+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';
+
+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 {
+    static { this.ID = 'workbench.contrib.scmMultiDiffSourceResolver'; }
+    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 };