@codingame/monaco-vscode-extensions-service-override 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/api/browser/mainThreadSCM.js

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { DisposableMap, DisposableStore, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { DisposableStore, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ISCMService, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
@@ -10,25 +10,9 @@ import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff';
 import { ResourceTree } from 'vscode/vscode/vs/base/common/resourceTree';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { basename } from 'vscode/vscode/vs/base/common/resources';
 
-function getSCMInputBoxActionButtonIcon(actionButton) {
-    if (!actionButton.icon) {
-        return undefined;
-    }
-    else if (URI.isUri(actionButton.icon)) {
-        return URI.revive(actionButton.icon);
-    }
-    else if (ThemeIcon.isThemeIcon(actionButton.icon)) {
-        return actionButton.icon;
-    }
-    else {
-        const icon = actionButton.icon;
-        return { light: URI.revive(icon.light), dark: URI.revive(icon.dark) };
-    }
-}
 function getIconFromIconDto(iconDto) {
     if (iconDto === undefined) {
         return undefined;
@@ -56,13 +40,14 @@ class MainThreadSCMResourceGroup {
         return this._resourceTree;
     }
     get hideWhenEmpty() { return !!this.features.hideWhenEmpty; }
-    constructor(sourceControlHandle, handle, provider, features, label, id, _uriIdentService) {
+    constructor(sourceControlHandle, handle, provider, features, label, id, multiDiffEditorEnableViewChanges, _uriIdentService) {
         this.sourceControlHandle = sourceControlHandle;
         this.handle = handle;
         this.provider = provider;
         this.features = features;
         this.label = label;
         this.id = id;
+        this.multiDiffEditorEnableViewChanges = multiDiffEditorEnableViewChanges;
         this._uriIdentService = _uriIdentService;
         this.resources = [];
         this._onDidChange = ( new Emitter());
@@ -92,7 +77,7 @@ class MainThreadSCMResourceGroup {
     }
 }
 class MainThreadSCMResource {
-    constructor(proxy, sourceControlHandle, groupHandle, handle, sourceUri, resourceGroup, decorations, contextValue, command) {
+    constructor(proxy, sourceControlHandle, groupHandle, handle, sourceUri, resourceGroup, decorations, contextValue, command, multiDiffEditorOriginalUri, multiDiffEditorModifiedUri) {
         this.proxy = proxy;
         this.sourceControlHandle = sourceControlHandle;
         this.groupHandle = groupHandle;
@@ -102,6 +87,8 @@ class MainThreadSCMResource {
         this.decorations = decorations;
         this.contextValue = contextValue;
         this.command = command;
+        this.multiDiffEditorOriginalUri = multiDiffEditorOriginalUri;
+        this.multiDiffEditorModifiedUri = multiDiffEditorModifiedUri;
     }
     open(preserveFocus) {
         return this.proxy.$executeResourceCommand(this.sourceControlHandle, this.groupHandle, this.handle, preserveFocus);
@@ -116,11 +103,6 @@ class MainThreadSCMResource {
     }
 }
 class MainThreadSCMHistoryProvider {
-    get actionButton() { return this._actionButton; }
-    set actionButton(actionButton) {
-        this._actionButton = actionButton;
-        this._onDidChangeActionButton.fire();
-    }
     get currentHistoryItemGroup() { return this._currentHistoryItemGroup; }
     set currentHistoryItemGroup(historyItemGroup) {
         this._currentHistoryItemGroup = historyItemGroup;
@@ -129,37 +111,9 @@ class MainThreadSCMHistoryProvider {
     constructor(proxy, handle) {
         this.proxy = proxy;
         this.handle = handle;
-        this._onDidChangeActionButton = ( new Emitter());
-        this.onDidChangeActionButton = this._onDidChangeActionButton.event;
         this._onDidChangeCurrentHistoryItemGroup = ( new Emitter());
         this.onDidChangeCurrentHistoryItemGroup = this._onDidChangeCurrentHistoryItemGroup.event;
     }
-    async resolveHistoryItemGroupDetails(historyItemGroup) {
-        const historyItemGroupBase = await this.resolveHistoryItemGroupBase(historyItemGroup.id);
-        const ancestor = historyItemGroupBase ?
-            await this.resolveHistoryItemGroupCommonAncestor(historyItemGroup.id, historyItemGroupBase.id) : undefined;
-        let incoming;
-        if (historyItemGroupBase) {
-            incoming = {
-                id: historyItemGroupBase.id,
-                label: historyItemGroupBase.label,
-                icon: Codicon.arrowCircleDown,
-                ancestor: ancestor?.id,
-                count: ancestor?.behind ?? 0,
-            };
-        }
-        const outgoing = {
-            id: historyItemGroup.id,
-            label: historyItemGroup.label,
-            icon: Codicon.arrowCircleUp,
-            ancestor: ancestor?.id,
-            count: ancestor?.ahead ?? 0,
-        };
-        return { incoming, outgoing };
-    }
-    async resolveHistoryItemGroupBase(historyItemGroupId) {
-        return this.proxy.$resolveHistoryItemGroupBase(this.handle, historyItemGroupId, CancellationToken.None);
-    }
     async resolveHistoryItemGroupCommonAncestor(historyItemGroupId1, historyItemGroupId2) {
         return this.proxy.$resolveHistoryItemGroupCommonAncestor(this.handle, historyItemGroupId1, historyItemGroupId2, CancellationToken.None);
     }
@@ -167,8 +121,12 @@ class MainThreadSCMHistoryProvider {
         const historyItems = await this.proxy.$provideHistoryItems(this.handle, historyItemGroupId, options, CancellationToken.None);
         return historyItems?.map(historyItem => ({ ...historyItem, icon: getIconFromIconDto(historyItem.icon) }));
     }
-    async provideHistoryItemChanges(historyItemId) {
-        const changes = await this.proxy.$provideHistoryItemChanges(this.handle, historyItemId, CancellationToken.None);
+    async provideHistoryItemSummary(historyItemId, historyItemParentId) {
+        const historyItem = await this.proxy.$provideHistoryItemSummary(this.handle, historyItemId, historyItemParentId, CancellationToken.None);
+        return historyItem ? { ...historyItem, icon: getIconFromIconDto(historyItem.icon) } : undefined;
+    }
+    async provideHistoryItemChanges(historyItemId, historyItemParentId) {
+        const changes = await this.proxy.$provideHistoryItemChanges(this.handle, historyItemId, historyItemParentId, CancellationToken.None);
         return changes?.map(change => ({
             uri: URI.revive(change.uri),
             originalUri: change.originalUri && URI.revive(change.originalUri),
@@ -260,8 +218,17 @@ class MainThreadSCMProvider {
         }
     }
     $registerGroups(_groups) {
-        const groups = ( _groups.map(([handle, id, label, features]) => {
-            const group = ( new MainThreadSCMResourceGroup(this.handle, handle, this, features, label, id, this._uriIdentService));
+        const groups = ( _groups.map(([handle, id, label, features, multiDiffEditorEnableViewChanges]) => {
+            const group = ( new MainThreadSCMResourceGroup(
+                this.handle,
+                handle,
+                this,
+                features,
+                label,
+                id,
+                multiDiffEditorEnableViewChanges,
+                this._uriIdentService
+            ));
             this._groupsByHandle[handle] = group;
             return group;
         }));
@@ -292,7 +259,7 @@ class MainThreadSCMProvider {
             groupSlices.reverse();
             for (const [start, deleteCount, rawResources] of groupSlices) {
                 const resources = ( rawResources.map(rawResource => {
-                    const [handle, sourceUri, icons, tooltip, strikeThrough, faded, contextValue, command] = rawResource;
+                    const [handle, sourceUri, icons, tooltip, strikeThrough, faded, contextValue, command, multiDiffEditorOriginalUri, multiDiffEditorModifiedUri] = rawResource;
                     const [light, dark] = icons;
                     const icon = ThemeIcon.isThemeIcon(light) ? light : URI.revive(light);
                     const iconDark = (ThemeIcon.isThemeIcon(dark) ? dark : URI.revive(dark)) || icon;
@@ -312,7 +279,9 @@ class MainThreadSCMProvider {
                         group,
                         decorations,
                         contextValue || undefined,
-                        command
+                        command,
+                        URI.revive(multiDiffEditorOriginalUri),
+                        URI.revive(multiDiffEditorModifiedUri)
                     ));
                 }));
                 group.splice(start, deleteCount, resources);
@@ -336,12 +305,6 @@ class MainThreadSCMProvider {
         const result = await this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None);
         return result && URI.revive(result);
     }
-    $onDidChangeHistoryProviderActionButton(actionButton) {
-        if (!this._historyProvider) {
-            return;
-        }
-        this._historyProvider.actionButton = actionButton ?? undefined;
-    }
     $onDidChangeHistoryProviderCurrentHistoryItemGroup(currentHistoryItemGroup) {
         if (!this._historyProvider) {
             return;
@@ -358,17 +321,6 @@ class MainThreadSCMProvider {
         this._quickDiff?.dispose();
     }
 }
-class MainThreadSCMInputBoxValueProvider {
-    constructor(proxy, handle, label, icon) {
-        this.proxy = proxy;
-        this.handle = handle;
-        this.label = label;
-        this.icon = icon;
-    }
-    provideValue(rootUri, context, token) {
-        return this.proxy.$provideInputBoxValue(this.handle, rootUri, context, token);
-    }
-}
 let MainThreadSCM = class MainThreadSCM {
     constructor(extHostContext, scmService, scmViewService, quickDiffService, _uriIdentService, workspaceContextService) {
         this.scmService = scmService;
@@ -378,7 +330,6 @@ let MainThreadSCM = class MainThreadSCM {
         this.workspaceContextService = workspaceContextService;
         this._repositories = ( new Map());
         this._repositoryDisposables = ( new Map());
-        this._inputBoxValueProviders = ( new DisposableMap());
         this._disposables = ( new DisposableStore());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSCM));
     }
@@ -387,7 +338,6 @@ let MainThreadSCM = class MainThreadSCM {
         this._repositories.clear();
         dispose(( this._repositoryDisposables.values()));
         this._repositoryDisposables.clear();
-        this._inputBoxValueProviders.dispose();
         this._disposables.dispose();
     }
     $registerSourceControl(handle, id, label, rootUri, inputBoxDocumentUri) {
@@ -431,19 +381,6 @@ let MainThreadSCM = class MainThreadSCM {
         repository.dispose();
         this._repositories.delete(handle);
     }
-    $registerSourceControlInputBoxValueProvider(handle, sourceControlId, label, icon) {
-        const provider = ( new MainThreadSCMInputBoxValueProvider(this._proxy, handle, label, getIconFromIconDto(icon)));
-        const disposable = this.scmService.registerSCMInputValueProvider(sourceControlId, provider);
-        this._inputBoxValueProviders.set(handle, disposable);
-    }
-    $unregisterSourceControlInputBoxValueProvider(handle) {
-        const provider = this._inputBoxValueProviders.get(handle);
-        if (!provider) {
-            return;
-        }
-        provider.dispose();
-        this._inputBoxValueProviders.deleteAndDispose(handle);
-    }
     $registerGroups(sourceControlHandle, groups, splices) {
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
@@ -513,13 +450,6 @@ let MainThreadSCM = class MainThreadSCM {
         }
         repository.input.visible = visible;
     }
-    $setInputBoxActionButton(sourceControlHandle, actionButton) {
-        const repository = this._repositories.get(sourceControlHandle);
-        if (!repository) {
-            return;
-        }
-        repository.input.actionButton = actionButton ? { ...actionButton, icon: getSCMInputBoxActionButtonIcon(actionButton) } : undefined;
-    }
     $showValidationMessage(sourceControlHandle, message, type) {
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
@@ -542,14 +472,6 @@ let MainThreadSCM = class MainThreadSCM {
             repository.input.validateInput = async () => undefined;
         }
     }
-    $onDidChangeHistoryProviderActionButton(sourceControlHandle, actionButton) {
-        const repository = this._repositories.get(sourceControlHandle);
-        if (!repository) {
-            return;
-        }
-        const provider = repository.provider;
-        provider.$onDidChangeHistoryProviderActionButton(actionButton);
-    }
     $onDidChangeHistoryProviderCurrentHistoryItemGroup(sourceControlHandle, historyItemGroup) {
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {

package/vscode/src/vs/workbench/api/browser/mainThreadSpeech.js

@@ -1,19 +1,19 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 
-let MainThreadSpeech = class MainThreadSpeech extends Disposable {
+let MainThreadSpeech = class MainThreadSpeech {
     constructor(extHostContext, speechService, logService) {
-        super();
         this.speechService = speechService;
         this.logService = logService;
         this.providerRegistrations = ( new Map());
-        this.providerSessions = ( new Map());
+        this.speechToTextSessions = ( new Map());
+        this.keywordRecognitionSessions = ( new Map());
         this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSpeech));
     }
     $registerProvider(handle, identifier, metadata) {
@@ -27,12 +27,29 @@ let MainThreadSpeech = class MainThreadSpeech extends Disposable {
                 this.proxy.$createSpeechToTextSession(handle, session);
                 disposables.add(token.onCancellationRequested(() => this.proxy.$cancelSpeechToTextSession(session)));
                 const onDidChange = disposables.add(( new Emitter()));
-                this.providerSessions.set(session, { onDidChange });
+                this.speechToTextSessions.set(session, { onDidChange });
                 return {
                     onDidChange: onDidChange.event,
                     dispose: () => {
                         cts.dispose(true);
-                        this.providerSessions.delete(session);
+                        this.speechToTextSessions.delete(session);
+                        disposables.dispose();
+                    }
+                };
+            },
+            createKeywordRecognitionSession: token => {
+                const disposables = ( new DisposableStore());
+                const cts = ( new CancellationTokenSource(token));
+                const session = Math.random();
+                this.proxy.$createKeywordRecognitionSession(handle, session);
+                disposables.add(token.onCancellationRequested(() => this.proxy.$cancelKeywordRecognitionSession(session)));
+                const onDidChange = disposables.add(( new Emitter()));
+                this.keywordRecognitionSessions.set(session, { onDidChange });
+                return {
+                    onDidChange: onDidChange.event,
+                    dispose: () => {
+                        cts.dispose(true);
+                        this.keywordRecognitionSessions.delete(session);
                         disposables.dispose();
                     }
                 };
@@ -52,10 +69,20 @@ let MainThreadSpeech = class MainThreadSpeech extends Disposable {
         }
     }
     $emitSpeechToTextEvent(session, event) {
-        const providerSession = this.providerSessions.get(session);
-        if (providerSession) {
-            providerSession.onDidChange.fire(event);
-        }
+        const providerSession = this.speechToTextSessions.get(session);
+        providerSession?.onDidChange.fire(event);
+    }
+    $emitKeywordRecognitionEvent(session, event) {
+        const providerSession = this.keywordRecognitionSessions.get(session);
+        providerSession?.onDidChange.fire(event);
+    }
+    dispose() {
+        this.providerRegistrations.forEach(disposable => disposable.dispose());
+        this.providerRegistrations.clear();
+        this.speechToTextSessions.forEach(session => session.onDidChange.dispose());
+        this.speechToTextSessions.clear();
+        this.keywordRecognitionSessions.forEach(session => session.onDidChange.dispose());
+        this.keywordRecognitionSessions.clear();
     }
 };
 MainThreadSpeech = __decorate([

package/vscode/src/vs/workbench/api/browser/mainThreadTesting.js

@@ -4,6 +4,7 @@ import { Disposable, MutableDisposable, DisposableStore, toDisposable } from 'vs
 import { WellDefinedPrefixTree } from 'vscode/vscode/vs/base/common/prefixTree';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
 import { MutableObservableValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/observableValue';
 import { TestCoverage } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverage';
 import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
@@ -16,8 +17,9 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 
 let MainThreadTesting = class MainThreadTesting extends Disposable {
-    constructor(extHostContext, testService, testProfiles, resultService) {
+    constructor(extHostContext, uriIdentityService, testService, testProfiles, resultService) {
         super();
+        this.uriIdentityService = uriIdentityService;
         this.testService = testService;
         this.testProfiles = testProfiles;
         this.resultService = resultService;
@@ -28,16 +30,11 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
             this.proxy.$cancelExtensionTestRun(runId);
         }));
         this._register(Event.debounce(testProfiles.onDidChange, (_last, e) => e)(() => {
-            const defaults = ( new Set([
-                ...testProfiles.getGroupDefaultProfiles(2 ),
-                ...testProfiles.getGroupDefaultProfiles(4 ),
-                ...testProfiles.getGroupDefaultProfiles(8 ),
-            ]));
             const obj = {};
             for (const { controller, profiles } of this.testProfiles.all()) {
-                obj[controller.id] = ( profiles.filter(p => ( defaults.has(p))).map(p => p.profileId));
+                obj[controller.id] = ( profiles.filter(p => p.isDefault).map(p => p.profileId));
             }
-            this.proxy.$setActiveRunProfiles(obj);
+            this.proxy.$setDefaultRunProfiles(obj);
         }));
         this._register(resultService.onResultsChanged(evt => {
             const results = 'completed' in evt ? evt.completed : ('inserted' in evt ? evt.inserted : undefined);
@@ -74,7 +71,7 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         this.testProfiles.removeProfile(controllerId, profileId);
     }
     $addTestsToRun(controllerId, runId, tests) {
-        this.withLiveRun(runId, r => r.addTestChainToRun(controllerId, ( tests.map(ITestItem.deserialize))));
+        this.withLiveRun(runId, r => r.addTestChainToRun(controllerId, ( tests.map(t => ITestItem.deserialize(this.uriIdentityService, t)))));
     }
     $signalCoverageAvailable(runId, taskId, available) {
         this.withLiveRun(runId, run => {
@@ -84,10 +81,10 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
             }
             const fn = available ? ((token) => TestCoverage.load(taskId, {
                 provideFileCoverage: async (token) => await this.proxy.$provideFileCoverage(runId, taskId, token)
-                    .then(c => ( c.map(IFileCoverage.deserialize))),
+                    .then(c => ( c.map(u => IFileCoverage.deserialize(this.uriIdentityService, u)))),
                 resolveFileCoverage: (i, token) => this.proxy.$resolveFileCoverage(runId, taskId, i, token)
                     .then(d => ( d.map(CoverageDetails.deserialize))),
-            }, token)) : undefined;
+            }, this.uriIdentityService, token)) : undefined;
             task.coverage.set(fn, undefined);
         });
     }
@@ -117,7 +114,7 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         const r = this.resultService.getResult(runId);
         if (r && r instanceof LiveTestResult) {
             for (const message of messages) {
-                r.appendMessage(testId, taskId, ITestMessage.deserialize(message));
+                r.appendMessage(testId, taskId, ITestMessage.deserialize(this.uriIdentityService, message));
             }
         }
     }
@@ -169,7 +166,7 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         this.diffListener.clear();
     }
     $publishDiff(controllerId, diff) {
-        this.testService.publishDiff(controllerId, ( diff.map(TestsDiffOp.deserialize)));
+        this.testService.publishDiff(controllerId, ( diff.map(d => TestsDiffOp.deserialize(this.uriIdentityService, d))));
     }
     async $runTests(req, token) {
         const result = await this.testService.runResolvedTests(req, token);
@@ -189,9 +186,10 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
 };
 MainThreadTesting = __decorate([
     extHostNamedCustomer(MainContext.MainThreadTesting),
-    ( __param(1, ITestService)),
-    ( __param(2, ITestProfileService)),
-    ( __param(3, ITestResultService))
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, ITestService)),
+    ( __param(3, ITestProfileService)),
+    ( __param(4, ITestResultService))
 ], MainThreadTesting);
 
 export { MainThreadTesting };

package/vscode/src/vs/workbench/api/browser/mainThreadTreeViews.js

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Disposable, DisposableMap, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IViewsService, Extensions, NoTreeViewError, ResolvableTreeItem } from 'vscode/vscode/vs/workbench/common/views';
+import { Extensions, NoTreeViewError, ResolvableTreeItem } from 'vscode/vscode/vs/workbench/common/views';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { distinct } from 'vscode/vscode/vs/base/common/arrays';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
@@ -12,6 +12,7 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { VSDataTransfer, createStringDataTransferItem } from 'vscode/vscode/vs/base/common/dataTransfer';
 import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
 import { DataTransfer } from 'vscode/vscode/vs/workbench/api/common/extHostTypeConverters';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 
 let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
     constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
@@ -235,6 +236,9 @@ class TreeViewDataProvider {
         this.hasResolve = this._proxy.$hasResolve(this.treeViewId);
     }
     getChildren(treeItem) {
+        if (!treeItem) {
+            this.itemsMap.clear();
+        }
         return this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : undefined)
             .then(children => this.postGetChildren(children), err => {
             if (!NoTreeViewError.is(err)) {

package/vscode/src/vs/workbench/contrib/comments/browser/commentThreadZoneWidget.js

@@ -16,6 +16,7 @@ import { CommentThreadWidget } from 'vscode/vscode/vs/workbench/contrib/comments
 import { commentThreadStateColorVar, commentThreadStateBackgroundColorVar, getCommentThreadStateBorderColor } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentColors';
 import { peekViewBorder } from 'vscode/vscode/vs/editor/contrib/peekView/browser/peekView';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { StableEditorScrollState } from 'vscode/vscode/vs/editor/browser/stableEditorScroll';
 
 function getCommentThreadWidgetStateColor(thread, theme) {
     return getCommentThreadStateBorderColor(thread, theme) ?? theme.getColor(peekViewBorder);
@@ -290,7 +291,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
         }));
         if (this._initialCollapsibleState === undefined) {
             const onDidChangeInitialCollapsibleState = this._commentThread.onDidChangeInitialCollapsibleState(state => {
-                this._initialCollapsibleState = this._commentThread.range ? state : CommentThreadCollapsibleState.Expanded;
+                this._initialCollapsibleState = state;
                 this._commentThread.collapsibleState = this._initialCollapsibleState;
                 onDidChangeInitialCollapsibleState.dispose();
             });
@@ -331,7 +332,9 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
             if (!this._commentThread.comments || !this._commentThread.comments.length) {
                 this._commentThreadWidget.focusCommentEditor();
             }
+            const capture = StableEditorScrollState.capture(this.editor);
             this._relayout(computedLinesNumber);
+            capture.restore(this.editor);
         }
     }
     _applyTheme(theme) {

package/vscode/src/vs/workbench/contrib/comments/browser/commentsController.js

@@ -20,7 +20,7 @@ import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/bro
 import { ReviewZoneWidget, parseMouseDownInfoFromEvent, isMouseUpEventDragFromMouseDown } from './commentThreadZoneWidget.js';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 import { EmbeddedCodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/embeddedCodeEditorWidget';
-import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { COMMENTS_VIEW_ID } from './commentsTreeViewer.js';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { COMMENTS_SECTION } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentsConfiguration';
@@ -508,6 +508,7 @@ let CommentController = class CommentController {
             return;
         }
         this._editorDisposables.push(this.editor.onMouseMove(e => this.onEditorMouseMove(e)));
+        this._editorDisposables.push(this.editor.onMouseLeave(() => this.onEditorMouseLeave()));
         this._editorDisposables.push(this.editor.onDidChangeCursorPosition(e => this.onEditorChangeCursorPosition(e.position)));
         this._editorDisposables.push(this.editor.onDidFocusEditorWidget(() => this.onEditorChangeCursorPosition(this.editor?.getPosition() ?? null)));
         this._editorDisposables.push(this.editor.onDidChangeCursorSelection(e => this.onEditorChangeCursorSelection(e)));
@@ -517,6 +518,9 @@ let CommentController = class CommentController {
         dispose(this._editorDisposables);
         this._editorDisposables = [];
     }
+    onEditorMouseLeave() {
+        this._commentingRangeDecorator.updateHover();
+    }
     onEditorMouseMove(e) {
         const position = e.target.position?.lineNumber;
         if (e.event.leftButton.valueOf() && position && this.mouseDownInfo) {

package/vscode/src/vs/workbench/contrib/comments/browser/commentsModel.js

@@ -0,0 +1,125 @@
+import { groupBy } from 'vscode/vscode/vs/base/common/arrays';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ResourceWithCommentThreads } from '../common/commentModel.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+class CommentsModel extends Disposable {
+    get resourceCommentThreads() { return this._resourceCommentThreads; }
+    constructor() {
+        super();
+        this._resourceCommentThreads = [];
+        this.commentThreadsMap = ( new Map());
+    }
+    updateResourceCommentThreads() {
+        const includeLabel = this.commentThreadsMap.size > 1;
+        this._resourceCommentThreads = ( [...( this.commentThreadsMap.values())].map(value => {
+            return ( value.resourceWithCommentThreads.map(resource => {
+                resource.ownerLabel = includeLabel ? value.ownerLabel : undefined;
+                return resource;
+            })).flat();
+        })).flat();
+        this._resourceCommentThreads.sort((a, b) => {
+            return ( a.resource.toString()) > ( b.resource.toString()) ? 1 : -1;
+        });
+    }
+    setCommentThreads(owner, ownerLabel, commentThreads) {
+        this.commentThreadsMap.set(owner, { ownerLabel, resourceWithCommentThreads: this.groupByResource(owner, commentThreads) });
+        this.updateResourceCommentThreads();
+    }
+    deleteCommentsByOwner(owner) {
+        if (owner) {
+            const existingOwner = this.commentThreadsMap.get(owner);
+            this.commentThreadsMap.set(owner, { ownerLabel: existingOwner?.ownerLabel, resourceWithCommentThreads: [] });
+        }
+        else {
+            this.commentThreadsMap.clear();
+        }
+        this.updateResourceCommentThreads();
+    }
+    updateCommentThreads(event) {
+        const { owner, ownerLabel, removed, changed, added } = event;
+        const threadsForOwner = this.commentThreadsMap.get(owner)?.resourceWithCommentThreads || [];
+        removed.forEach(thread => {
+            const matchingResourceIndex = threadsForOwner.findIndex((resourceData) => resourceData.id === thread.resource);
+            const matchingResourceData = matchingResourceIndex >= 0 ? threadsForOwner[matchingResourceIndex] : undefined;
+            const index = matchingResourceData?.commentThreads.findIndex((commentThread) => commentThread.threadId === thread.threadId) ?? 0;
+            if (index >= 0) {
+                matchingResourceData?.commentThreads.splice(index, 1);
+            }
+            if (matchingResourceData?.commentThreads.length === 0) {
+                threadsForOwner.splice(matchingResourceIndex, 1);
+            }
+        });
+        changed.forEach(thread => {
+            const matchingResourceIndex = threadsForOwner.findIndex((resourceData) => resourceData.id === thread.resource);
+            const matchingResourceData = matchingResourceIndex >= 0 ? threadsForOwner[matchingResourceIndex] : undefined;
+            if (!matchingResourceData) {
+                return;
+            }
+            const index = matchingResourceData.commentThreads.findIndex((commentThread) => commentThread.threadId === thread.threadId);
+            if (index >= 0) {
+                matchingResourceData.commentThreads[index] = ResourceWithCommentThreads.createCommentNode(owner, ( URI.parse(matchingResourceData.id)), thread);
+            }
+            else if (thread.comments && thread.comments.length) {
+                matchingResourceData.commentThreads.push(ResourceWithCommentThreads.createCommentNode(owner, ( URI.parse(matchingResourceData.id)), thread));
+            }
+        });
+        added.forEach(thread => {
+            const existingResource = threadsForOwner.filter(resourceWithThreads => ( resourceWithThreads.resource.toString()) === thread.resource);
+            if (existingResource.length) {
+                const resource = existingResource[0];
+                if (thread.comments && thread.comments.length) {
+                    resource.commentThreads.push(ResourceWithCommentThreads.createCommentNode(owner, resource.resource, thread));
+                }
+            }
+            else {
+                threadsForOwner.push(( new ResourceWithCommentThreads(owner, ( URI.parse(thread.resource)), [thread])));
+            }
+        });
+        this.commentThreadsMap.set(owner, { ownerLabel, resourceWithCommentThreads: threadsForOwner });
+        this.updateResourceCommentThreads();
+        return removed.length > 0 || changed.length > 0 || added.length > 0;
+    }
+    hasCommentThreads() {
+        return !!this._resourceCommentThreads.length;
+    }
+    getMessage() {
+        if (!this._resourceCommentThreads.length) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsModel',
+                'noComments',
+                "There are no comments in this workspace yet."
+            ));
+        }
+        else {
+            return '';
+        }
+    }
+    groupByResource(owner, commentThreads) {
+        const resourceCommentThreads = [];
+        const commentThreadsByResource = ( new Map());
+        for (const group of groupBy(commentThreads, CommentsModel._compareURIs)) {
+            commentThreadsByResource.set(group[0].resource, ( new ResourceWithCommentThreads(owner, ( URI.parse(group[0].resource)), group)));
+        }
+        commentThreadsByResource.forEach((v, i, m) => {
+            resourceCommentThreads.push(v);
+        });
+        return resourceCommentThreads;
+    }
+    static _compareURIs(a, b) {
+        const resourceA = ( a.resource.toString());
+        const resourceB = ( b.resource.toString());
+        if (resourceA < resourceB) {
+            return -1;
+        }
+        else if (resourceA > resourceB) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+
+export { CommentsModel };