@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -1,14 +1,15 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { LazyStatefulPromise, raceTimeout } from '../../../../base/common/async.js';
 import { BugIndicatingError, onUnexpectedError } from '../../../../base/common/errors.js';
-import { Event, Emitter } from '../../../../base/common/event.js';
+import { ValueWithChangeEvent, Event } from '../../../../base/common/event.js';
 import { Disposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import { parse } from '../../../../base/common/marshalling.js';
 import { Schemas } from '../../../../base/common/network.js';
 import { deepClone } from '../../../../base/common/objects.js';
+import { observableValue } from '../../../../base/common/observableInternal/base.js';
 import { derived } from '../../../../base/common/observableInternal/derived.js';
 import { autorun } from '../../../../base/common/observableInternal/autorun.js';
-import { observableFromEvent, constObservable, mapObservableArrayCached } from '../../../../base/common/observableInternal/utils.js';
+import { observableFromValueWithChangeEvent, constObservable, mapObservableArrayCached, recomputeInitiallyAndOnChange, ValueWithChangeEventFromObservable, observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
 import { ObservableLazyPromise } from '../../../../base/common/observableInternal/promise.js';
 import { isDefined, isObject } from '../../../../base/common/types.js';
 import { URI } from '../../../../base/common/uri.js';
@@ -21,25 +22,33 @@ import { IInstantiationService } from '../../../../platform/instantiation/common
 import { DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
 import { EditorInput } from '../../../common/editor/editorInput.js';
 import { MultiDiffEditorIcon } from './icons.contribution.js';
-import { MultiDiffEditorItem, ConstResolvedMultiDiffSource } from './multiDiffSourceResolverService.js';
+import { MultiDiffEditorItem } from './multiDiffSourceResolverService.js';
 import { IMultiDiffSourceResolverService } from './multiDiffSourceResolverService.service.js';
 import { RegisteredEditorPriority } from '../../../services/editor/common/editorResolverService.js';
 import { IEditorResolverService } from '../../../services/editor/common/editorResolverService.service.js';
 import { ITextFileService } from '../../../services/textfile/common/textfiles.service.js';
 var MultiDiffEditorInput_1;
+const _moduleId = "vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput";
 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');
+            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())}`));
+        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));
+            return (
+                 (new MultiDiffEditorItem(resource.original.resource, resource.modified.resource))
+            );
         }), input.isTransient ?? false);
     }
     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))), false);
+        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
+        )))), false);
     }
     static { this.ID = 'workbench.input.multiDiffEditor'; }
     get resource() { return this.multiDiffSource; }
@@ -60,30 +69,30 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
         this._multiDiffSourceResolverService = _multiDiffSourceResolverService;
         this._textFileService = _textFileService;
         this._name = '';
-        this._viewModel = ( new LazyStatefulPromise(async () => {
+        this._viewModel = ( (new LazyStatefulPromise(async () => {
             const model = await this._createModel();
             this._register(model);
-            const vm = ( new MultiDiffEditorViewModel(model, this._instantiationService));
+            const vm = ( (new MultiDiffEditorViewModel(model, this._instantiationService)));
             this._register(vm);
             await raceTimeout(vm.waitForDiffs(), 1000);
             return vm;
-        }));
-        this._resolvedSource = ( new ObservableLazyPromise(async () => {
+        })));
+        this._resolvedSource = ( (new ObservableLazyPromise(async () => {
             const source = this.initialResources
-                ? ( new ConstResolvedMultiDiffSource(this.initialResources))
+                ? { resources: ValueWithChangeEvent.const(this.initialResources) }
                 : await this._multiDiffSourceResolverService.resolve(this.multiDiffSource);
             return {
                 source,
-                resources: source ? observableFromEvent(source.onDidChange, () => source.resources) : constObservable([]),
+                resources: source ? observableFromValueWithChangeEvent(this, source.resources) : constObservable([]),
             };
-        }));
-        this._resources = derived(this, reader => this._resolvedSource.cachedPromiseResult.read(reader)?.data?.resources.read(reader));
-        this._isDirtyObservables = mapObservableArrayCached(this, ( this._resources.map(r => r || [])), res => {
+        })));
+        this.resources = derived(this, reader => this._resolvedSource.cachedPromiseResult.read(reader)?.data?.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))))
+        }, i => i.getKey());
+        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 = {
@@ -95,23 +104,21 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
             }
         };
         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', {
-                key: 'files',
-                comment: ['the number of files being shown']
-            }, " ({0} files)", resources?.length ?? 0));
+            const resources = this.resources.read(reader);
+            const label = this.label ?? ( localizeWithPath(_moduleId, 0, "Multi Diff Editor"));
+            if (resources) {
+                this._name = label + ( localizeWithPath(_moduleId, 1, " ({0} files)", resources.length));
+            }
+            else {
+                this._name = label;
+            }
             this._onDidChangeLabel.fire();
         }));
     }
     serialize() {
         return {
             label: this.label,
-            multiDiffSourceUri: ( this.multiDiffSource.toString()),
+            multiDiffSourceUri: ( (this.multiDiffSource.toString())),
             resources: this.initialResources?.map(resource => ({
                 originalUri: resource.original?.toString(),
                 modifiedUri: resource.modified?.toString(),
@@ -136,11 +143,11 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
     async _createModel() {
         const source = await this._resolvedSource.getPromise();
         const textResourceConfigurationService = this._textResourceConfigurationService;
-        const garbage = ( new DisposableStore());
-        const documentsWithPromises = mapObservableArrayCached(undefined, source.resources, async (r, store) => {
+        const garbage = ( (new DisposableStore()));
+        const documentsWithPromises = mapObservableArrayCached(this, source.resources, async (r, store) => {
             let original;
             let modified;
-            const store2 = ( new DisposableStore());
+            const store2 = ( (new DisposableStore()));
             store.add(toDisposable(() => {
                 garbage.add(store2);
             }));
@@ -150,10 +157,10 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
                     r.modified ? this._textModelService.createModelReference(r.modified) : undefined,
                 ]);
                 if (original) {
-                    store.add(original);
+                    store2.add(original);
                 }
                 if (modified) {
-                    store.add(modified);
+                    store2.add(modified);
                 }
             }
             catch (e) {
@@ -162,49 +169,50 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
                 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();
-                    }
-                }),
-            }));
+            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 documents = observableValue('documents', []);
+        const updateDocuments = derived(async (reader) => {
             const docsPromises = documentsWithPromises.read(reader);
             const docs = await Promise.all(docsPromises);
-            documents = docs.filter(isDefined);
-            documentChangeEmitter.fire();
+            const newDocuments = docs.filter(isDefined);
+            documents.set(newDocuments, undefined);
             garbage.clear();
         });
-        await p;
-        return {
+        const a = recomputeInitiallyAndOnChange(updateDocuments);
+        await updateDocuments.get();
+        const result = {
             dispose: () => {
                 a.dispose();
                 garbage.dispose();
             },
-            onDidChange: documentChangeEmitter.event,
-            get documents() { return documents; },
+            documents: ( (new ValueWithChangeEventFromObservable(documents))),
             contextKeys: source.source?.contextKeys,
         };
+        return result;
     }
     matches(otherInput) {
         if (super.matches(otherInput)) {
             return true;
         }
         if (otherInput instanceof MultiDiffEditorInput_1) {
-            return ( this.multiDiffSource.toString()) === ( otherInput.multiDiffSource.toString());
+            return ( (this.multiDiffSource.toString())) === ( (otherInput.multiDiffSource.toString()));
         }
         return false;
     }
@@ -219,27 +227,27 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
     async doSaveOrRevert(mode, group, options) {
         const items = this._viewModel.currentValue?.items.get();
         if (items) {
-            await Promise.all(( items.map(async (item) => {
+            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(4, ITextModelService)),
-    ( __param(5, ITextResourceConfigurationService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IMultiDiffSourceResolverService)),
-    ( __param(8, ITextFileService))
-], MultiDiffEditorInput));
+MultiDiffEditorInput = MultiDiffEditorInput_1 = ( (__decorate([
+    ( (__param(4, ITextModelService))),
+    ( (__param(5, ITextResourceConfigurationService))),
+    ( (__param(6, IInstantiationService))),
+    ( (__param(7, IMultiDiffSourceResolverService))),
+    ( (__param(8, ITextFileService)))
+], MultiDiffEditorInput)));
 function isUriDirty(textFileService, uri) {
-    return observableFromEvent(Event.filter(textFileService.files.onDidChangeDirty, e => ( e.resource.toString()) === ( uri.toString())), () => textFileService.isDirty(uri));
+    return observableFromEvent(Event.filter(textFileService.files.onDidChangeDirty, e => ( (e.resource.toString())) === ( (uri.toString()))), () => textFileService.isDirty(uri));
 }
 function getReadonlyConfiguration(isReadonly) {
     return {
@@ -277,10 +285,10 @@ let MultiDiffEditorResolverContribution = class MultiDiffEditorResolverContribut
         }));
     }
 };
-MultiDiffEditorResolverContribution = ( __decorate([
-    ( __param(0, IEditorResolverService)),
-    ( __param(1, IInstantiationService))
-], MultiDiffEditorResolverContribution));
+MultiDiffEditorResolverContribution = ( (__decorate([
+    ( (__param(0, IEditorResolverService))),
+    ( (__param(1, IInstantiationService)))
+], MultiDiffEditorResolverContribution)));
 class MultiDiffEditorSerializer {
     canSerialize(editor) {
         return editor instanceof MultiDiffEditorInput && !editor.isTransient;

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

@@ -1,20 +1,16 @@
-import { Event } from '../../../../base/common/event.js';
-import { toDisposable } from '../../../../base/common/lifecycle.js';
 import { BugIndicatingError } from '../../../../base/common/errors.js';
-class ConstResolvedMultiDiffSource {
-    constructor(resources) {
-        this.resources = resources;
-        this.onDidChange = Event.None;
-    }
-}
+import { toDisposable } from '../../../../base/common/lifecycle.js';
 class MultiDiffEditorItem {
     constructor(original, modified) {
         this.original = original;
         this.modified = modified;
         if (!original && !modified) {
-            throw new BugIndicatingError('Invalid arguments');
+            throw ( new BugIndicatingError('Invalid arguments'));
         }
     }
+    getKey() {
+        return JSON.stringify([this.modified?.toString(), this.original?.toString()]);
+    }
 }
 class MultiDiffSourceResolverService {
     constructor() {
@@ -22,7 +18,7 @@ class MultiDiffSourceResolverService {
     }
     registerResolver(resolver) {
         if (( this._resolvers.has(resolver))) {
-            throw new BugIndicatingError('Duplicate resolver');
+            throw ( new BugIndicatingError('Duplicate resolver'));
         }
         this._resolvers.add(resolver);
         return toDisposable(() => this._resolvers.delete(resolver));
@@ -36,4 +32,4 @@ class MultiDiffSourceResolverService {
         return Promise.resolve(undefined);
     }
 }
-export { ConstResolvedMultiDiffSource, MultiDiffEditorItem, MultiDiffSourceResolverService };
+export { MultiDiffEditorItem, MultiDiffSourceResolverService };

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

@@ -0,0 +1,112 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/arrays.js';
+import '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent, ValueWithChangeEventFromObservable } from '../../../../base/common/observableInternal/utils.js';
+import { waitForState } from '../../../../base/common/observableInternal/promise.js';
+import { URI } from '../../../../base/common/uri.js';
+import { localize2WithPath } from '../../../../nls.js';
+import { Action2 } from '../../../../platform/actions/common/actions.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { MultiDiffEditorItem } from './multiDiffSourceResolverService.js';
+import { IMultiDiffSourceResolverService } from './multiDiffSourceResolverService.service.js';
+import { ISCMService } from '../../scm/common/scm.service.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+var ScmMultiDiffSourceResolver_1;
+const _moduleId = "vs/workbench/contrib/multiDiffEditor/browser/scmMultiDiffSourceResolver";
+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 waitForState(observableFromEvent(this._scmService.onDidAddRepository, () => [...this._scmService.repositories].find(r => r.provider.rootUri?.toString() === ( (repositoryUri.toString())))));
+        const group = await waitForState(observableFromEvent(repository.provider.onDidChangeResourceGroups, () => repository.provider.groups.find(g => g.id === groupId)));
+        return (
+             (new ScmResolvedMultiDiffSource(group, repository))
+        );
+    }
+};
+ScmMultiDiffSourceResolver = ScmMultiDiffSourceResolver_1 = ( (__decorate([
+    ( (__param(0, ISCMService)))
+], ScmMultiDiffSourceResolver)));
+class ScmResolvedMultiDiffSource {
+    constructor(_group, _repository) {
+        this._group = _group;
+        this._repository = _repository;
+        this._resources = observableFromEvent(this._group.onDidChangeResources, () => (  (this._group.resources.map(
+            e => ( (new MultiDiffEditorItem(e.multiDiffEditorOriginalUri, e.multiDiffEditorModifiedUri)))
+        ))));
+        this.resources = ( (new ValueWithChangeEventFromObservable(this._resources)));
+        this.contextKeys = {
+            scmResourceGroup: this._group.id,
+            scmProvider: this._repository.provider.contextValue,
+        };
+    }
+}
+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 {
+    static async openMultiFileDiffEditor(editorService, label, repositoryRootUri, resourceGroupId, options) {
+        if (!repositoryRootUri) {
+            return;
+        }
+        const multiDiffSource = ScmMultiDiffSourceResolver.getMultiDiffSourceUri(( (repositoryRootUri.toString())), resourceGroupId);
+        return await editorService.openEditor({ label, multiDiffSource, options });
+    }
+    constructor() {
+        super({
+            id: '_workbench.openScmMultiDiffEditor',
+            title: ( localize2WithPath(_moduleId, 0, 'View Changes')),
+            f1: false
+        });
+    }
+    async run(accessor, options) {
+        const editorService = accessor.get(IEditorService);
+        await OpenScmGroupAction.openMultiFileDiffEditor(editorService, options.title, URI.revive(options.repositoryUri), options.resourceGroupId);
+    }
+}
+export { OpenScmGroupAction, ScmMultiDiffSourceResolver, ScmMultiDiffSourceResolverContribution };