@codingame/monaco-vscode-api 3.2.2 → 4.0.0

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

@@ -1,7 +1,17 @@
 import { CommentThreadState } from '../../../../editor/common/languages.js';
 import { peekViewTitleBackground } from '../../../../editor/contrib/peekView/browser/peekView.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { registerColor, disabledForeground, contrastBorder, listFocusOutline, transparent } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerColor, transparent } from '../../../../platform/theme/common/colorUtils.js';
+import { disabledForeground, contrastBorder } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import { listFocusOutline } from '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
 const resolvedCommentViewIcon = registerColor('commentsView.resolvedIcon', { dark: disabledForeground, light: disabledForeground, hcDark: contrastBorder, hcLight: contrastBorder }, ( localizeWithPath(
     'vs/workbench/contrib/comments/browser/commentColors',
     'resolvedCommentIcon',

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

@@ -2,7 +2,17 @@ import { localizeWithPath } from '../../../../nls.js';
 import { Color } from '../../../../base/common/color.js';
 import { OverviewRulerLane } from '../../../../editor/common/model.js';
 import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
-import { registerColor, opaque, darken, editorForeground, editorBackground, listInactiveSelectionBackground } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerColor, opaque, darken } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorForeground, editorBackground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import { listInactiveSelectionBackground } from '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
 import { themeColorFromId } from '../../../../platform/theme/common/themeService.js';
 import { CommentThreadState } from '../../../../editor/common/languages.js';
 const overviewRulerCommentingRangeForeground = registerColor('editorGutter.commentRangeForeground', { dark: opaque(listInactiveSelectionBackground, editorBackground), light: ( darken(opaque(listInactiveSelectionBackground, editorBackground), .05)), hcDark: Color.white, hcLight: Color.black }, ( localizeWithPath(

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

@@ -83,12 +83,8 @@ let CommentNode = class CommentNode extends Disposable {
         }
         this._commentMenus = this.commentService.getCommentMenus(this.owner);
         this._domNode.tabIndex = -1;
-        const avatar = append(this._domNode, $('div.avatar-container'));
-        if (comment.userIconPath) {
-            const img = append(avatar, $('img.avatar'));
-            img.src = ( FileAccess.uriToBrowserUri(URI.revive(comment.userIconPath)).toString(true));
-            img.onerror = _ => img.remove();
-        }
+        this._avatar = append(this._domNode, $('div.avatar-container'));
+        this.updateCommentUserIcon(this.comment.userIconPath);
         this._commentDetailsContainer = append(this._domNode, $('.review-comment-contents'));
         this.createHeader(this._commentDetailsContainer);
         this._body = document.createElement(`div`);
@@ -163,6 +159,14 @@ let CommentNode = class CommentNode extends Disposable {
             this._body.appendChild(this._md);
         }
     }
+    updateCommentUserIcon(userIconPath) {
+        this._avatar.textContent = '';
+        if (userIconPath) {
+            const img = append(this._avatar, $('img.avatar'));
+            img.src = ( FileAccess.uriToBrowserUri(URI.revive(userIconPath)).toString(true));
+            img.onerror = _ => img.remove();
+        }
+    }
     get onDidClick() {
         return this._onDidClick.event;
     }
@@ -235,16 +239,17 @@ let CommentNode = class CommentNode extends Disposable {
     }
     createToolbar() {
         this.toolbar = ( new ToolBar(this._actionsToolbarContainer, this.contextMenuService, {
-            actionViewItemProvider: action => {
+            actionViewItemProvider: (action, options) => {
                 if (action.id === ToggleReactionsAction.ID) {
                     return ( new DropdownMenuActionViewItem(action, action.menuActions, this.contextMenuService, {
-                        actionViewItemProvider: action => this.actionViewItemProvider(action),
+                        ...options,
+                        actionViewItemProvider: (action, options) => this.actionViewItemProvider(action, options),
                         actionRunner: this.actionRunner,
                         classNames: ['toolbar-toggle-pickReactions', ...ThemeIcon.asClassNameArray(Codicon.reactions)],
                         anchorAlignmentProvider: () => 1
                     }));
                 }
-                return this.actionViewItemProvider(action);
+                return this.actionViewItemProvider(action, options);
             },
             orientation: 0
         }));
@@ -276,8 +281,7 @@ let CommentNode = class CommentNode extends Disposable {
             this.toolbar.setActions(actions, secondary);
         }
     }
-    actionViewItemProvider(action) {
-        let options = {};
+    actionViewItemProvider(action, options) {
         if (action.id === ToggleReactionsAction.ID) {
             options = { label: false, icon: true };
         }
@@ -289,10 +293,10 @@ let CommentNode = class CommentNode extends Disposable {
             return item;
         }
         else if (action instanceof MenuItemAction) {
-            return this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+            return this.instantiationService.createInstance(MenuEntryActionViewItem, action, { hoverDelegate: options.hoverDelegate });
         }
         else if (action instanceof SubmenuItemAction) {
-            return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, undefined);
+            return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, options);
         }
         else {
             const item = ( new ActionViewItem({}, action, options));
@@ -350,11 +354,11 @@ let CommentNode = class CommentNode extends Disposable {
             toggleReactionAction.menuActions,
             this.contextMenuService,
             {
-                actionViewItemProvider: action => {
+                actionViewItemProvider: (action, options) => {
                     if (action.id === ToggleReactionsAction.ID) {
                         return toggleReactionActionViewItem;
                     }
-                    return this.actionViewItemProvider(action);
+                    return this.actionViewItemProvider(action, options);
                 },
                 actionRunner: this.actionRunner,
                 classNames: 'toolbar-toggle-pickReactions',
@@ -366,16 +370,16 @@ let CommentNode = class CommentNode extends Disposable {
     createReactionsContainer(commentDetailsContainer) {
         this._reactionActionsContainer = append(commentDetailsContainer, $('div.comment-reactions'));
         this._reactionsActionBar = ( new ActionBar(this._reactionActionsContainer, {
-            actionViewItemProvider: action => {
+            actionViewItemProvider: (action, options) => {
                 if (action.id === ToggleReactionsAction.ID) {
                     return ( new DropdownMenuActionViewItem(action, action.menuActions, this.contextMenuService, {
-                        actionViewItemProvider: action => this.actionViewItemProvider(action),
+                        actionViewItemProvider: (action, options) => this.actionViewItemProvider(action, options),
                         actionRunner: this.actionRunner,
                         classNames: ['toolbar-toggle-pickReactions', ...ThemeIcon.asClassNameArray(Codicon.reactions)],
                         anchorAlignmentProvider: () => 1
                     }));
                 }
-                return this.actionViewItemProvider(action);
+                return this.actionViewItemProvider(action, options);
             }
         }));
         this._register(this._reactionsActionBar);
@@ -569,6 +573,9 @@ let CommentNode = class CommentNode extends Disposable {
         if (newComment.body !== this.comment.body) {
             this.updateCommentBody(newComment.body);
         }
+        if (this.comment.userIconPath && newComment.userIconPath && (( ( URI.from(this.comment.userIconPath)).toString()) !== ( ( URI.from(newComment.userIconPath)).toString()))) {
+            this.updateCommentUserIcon(newComment.userIconPath);
+        }
         const isChangingMode = newComment.mode !== undefined && newComment.mode !== this.comment.mode;
         this.comment = newComment;
         if (isChangingMode) {

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

@@ -8,13 +8,25 @@ import { ILanguageService } from '../../../../editor/common/languages/language.j
 import { IModelService } from '../../../../editor/common/services/model.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { resolveColorValue, editorForeground } from '../../../../platform/theme/common/colorRegistry.js';
+import { resolveColorValue } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.js';
 import { CommentFormActions } from './commentFormActions.js';
 import { ICommentService } from './commentService.js';
 import { CommentContextKeys } from '../common/commentContextKeys.js';
 import { MIN_EDITOR_HEIGHT, SimpleCommentEditor, calculateEditorHeight } from './simpleCommentEditor.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 const COMMENT_SCHEME = 'comment';
 let INMEM_MODEL_ID = 0;
 const COMMENTEDITOR_DECORATION_KEY = 'commenteditordecoration';
@@ -292,7 +304,7 @@ let CommentReply = class CommentReply extends Disposable {
     }
     createReplyButton(commentEditor, commentForm) {
         this._reviewThreadReplyButton = append(commentForm, $(`button.review-thread-reply-button.${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`));
-        this._reviewThreadReplyButton.title = this._commentOptions?.prompt || ( localizeWithPath('vs/workbench/contrib/comments/browser/commentReply', 'reply', "Reply..."));
+        this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this._reviewThreadReplyButton, this._commentOptions?.prompt || ( localizeWithPath('vs/workbench/contrib/comments/browser/commentReply', 'reply', "Reply..."))));
         this._reviewThreadReplyButton.textContent = this._commentOptions?.prompt || ( localizeWithPath('vs/workbench/contrib/comments/browser/commentReply', 'reply', "Reply..."));
         this._register(addDisposableListener(this._reviewThreadReplyButton, 'click', _ => this.clearAndExpandReplyArea()));
         this._register(addDisposableListener(this._reviewThreadReplyButton, 'focus', _ => this.clearAndExpandReplyArea()));

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

@@ -13,16 +13,18 @@ import { IStorageService } from '../../../../platform/storage/common/storage.js'
 import { CommentContextKeys } from '../common/commentContextKeys.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
 import { CommentsModel } from './commentsModel.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
 const ICommentService = ( createDecorator('commentService'));
 const CONTINUE_ON_COMMENTS = 'comments.continueOnComments';
 let CommentService = class CommentService extends Disposable {
-    constructor(instantiationService, layoutService, configurationService, contextKeyService, storageService, logService) {
+    constructor(instantiationService, layoutService, configurationService, contextKeyService, storageService, logService, modelService) {
         super();
         this.instantiationService = instantiationService;
         this.layoutService = layoutService;
         this.configurationService = configurationService;
         this.storageService = storageService;
         this.logService = logService;
+        this.modelService = modelService;
         this._onDidSetDataProvider = this._register(( new Emitter()));
         this.onDidSetDataProvider = this._onDidSetDataProvider.event;
         this._onDidDeleteDataProvider = this._register(( new Emitter()));
@@ -52,6 +54,8 @@ let CommentService = class CommentService extends Disposable {
         this._continueOnCommentProviders = ( new Set());
         this._commentsModel = this._register(( new CommentsModel()));
         this.commentsModel = this._commentsModel;
+        this._commentingRangeResources = ( new Set());
+        this._commentingRangeResourceHintSchemes = ( new Set());
         this._handleConfiguration();
         this._handleZenMode();
         this._workspaceHasCommenting = CommentContextKeys.WorkspaceHasCommenting.bindTo(contextKeyService);
@@ -67,15 +71,16 @@ let CommentService = class CommentService extends Disposable {
             }
             this.logService.debug(`Comments: URIs of continue on comments from storage ${( commentsToRestore.map(thread => ( thread.uri.toString()))).join(', ')}.`);
             const changedOwners = this._addContinueOnComments(commentsToRestore, this._continueOnComments);
-            for (const owner of changedOwners) {
-                const control = this._commentControls.get(owner);
+            for (const uniqueOwner of changedOwners) {
+                const control = this._commentControls.get(uniqueOwner);
                 if (!control) {
                     continue;
                 }
                 const evt = {
-                    owner,
+                    uniqueOwner: uniqueOwner,
+                    owner: control.owner,
                     ownerLabel: control.label,
-                    pending: this._continueOnComments.get(owner) || [],
+                    pending: this._continueOnComments.get(uniqueOwner) || [],
                     added: [],
                     removed: [],
                     changed: []
@@ -91,6 +96,18 @@ let CommentService = class CommentService extends Disposable {
             }
             this._saveContinueOnComments(map);
         }));
+        this._register(this.modelService.onModelAdded(model => {
+            if (!( this._commentingRangeResources.has(( model.uri.toString())))) {
+                this.getDocumentComments(model.uri);
+            }
+        }));
+    }
+    _updateResourcesWithCommentingRanges(resource, commentInfos) {
+        for (const comments of commentInfos) {
+            if (comments && (comments.commentingRanges.ranges.length > 0 || comments.threads.length > 0)) {
+                this._commentingRangeResources.add(( resource.toString()));
+            }
+        }
     }
     _handleConfiguration() {
         this._isCommentingEnabled = this._defaultCommentingEnablement;
@@ -130,8 +147,8 @@ let CommentService = class CommentService extends Disposable {
     setActiveEditingCommentThread(commentThread) {
         this._onDidChangeActiveEditingCommentThread.fire(commentThread);
     }
-    async setActiveCommentAndThread(owner, commentInfo) {
-        const commentController = this._commentControls.get(owner);
+    async setActiveCommentAndThread(uniqueOwner, commentInfo) {
+        const commentController = this._commentControls.get(uniqueOwner);
         if (!commentController) {
             return;
         }
@@ -144,89 +161,94 @@ let CommentService = class CommentService extends Disposable {
     setDocumentComments(resource, commentInfos) {
         this._onDidSetResourceCommentInfos.fire({ resource, commentInfos });
     }
-    setModelThreads(ownerId, ownerLabel, commentThreads) {
-        this._commentsModel.setCommentThreads(ownerId, ownerLabel, commentThreads);
+    setModelThreads(ownerId, owner, ownerLabel, commentThreads) {
+        this._commentsModel.setCommentThreads(ownerId, owner, ownerLabel, commentThreads);
         this._onDidSetAllCommentThreads.fire({ ownerId, ownerLabel, commentThreads });
     }
     updateModelThreads(event) {
         this._commentsModel.updateCommentThreads(event);
         this._onDidUpdateCommentThreads.fire(event);
     }
-    setWorkspaceComments(owner, commentsByResource) {
+    setWorkspaceComments(uniqueOwner, commentsByResource) {
         if (commentsByResource.length) {
             this._workspaceHasCommenting.set(true);
         }
-        const control = this._commentControls.get(owner);
+        const control = this._commentControls.get(uniqueOwner);
         if (control) {
-            this.setModelThreads(owner, control.label, commentsByResource);
+            this.setModelThreads(uniqueOwner, control.owner, control.label, commentsByResource);
         }
     }
-    removeWorkspaceComments(owner) {
-        const control = this._commentControls.get(owner);
+    removeWorkspaceComments(uniqueOwner) {
+        const control = this._commentControls.get(uniqueOwner);
         if (control) {
-            this.setModelThreads(owner, control.label, []);
+            this.setModelThreads(uniqueOwner, control.owner, control.label, []);
         }
     }
-    registerCommentController(owner, commentControl) {
-        this._commentControls.set(owner, commentControl);
+    registerCommentController(uniqueOwner, commentControl) {
+        this._commentControls.set(uniqueOwner, commentControl);
         this._onDidSetDataProvider.fire();
     }
-    unregisterCommentController(owner) {
-        if (owner) {
-            this._commentControls.delete(owner);
+    unregisterCommentController(uniqueOwner) {
+        if (uniqueOwner) {
+            this._commentControls.delete(uniqueOwner);
         }
         else {
             this._commentControls.clear();
         }
-        this._commentsModel.deleteCommentsByOwner(owner);
-        this._onDidDeleteDataProvider.fire(owner);
+        this._commentsModel.deleteCommentsByOwner(uniqueOwner);
+        this._onDidDeleteDataProvider.fire(uniqueOwner);
     }
-    getCommentController(owner) {
-        return this._commentControls.get(owner);
+    getCommentController(uniqueOwner) {
+        return this._commentControls.get(uniqueOwner);
     }
-    async createCommentThreadTemplate(owner, resource, range) {
-        const commentController = this._commentControls.get(owner);
+    async createCommentThreadTemplate(uniqueOwner, resource, range) {
+        const commentController = this._commentControls.get(uniqueOwner);
         if (!commentController) {
             return;
         }
         return commentController.createCommentThreadTemplate(resource, range);
     }
-    async updateCommentThreadTemplate(owner, threadHandle, range) {
-        const commentController = this._commentControls.get(owner);
+    async updateCommentThreadTemplate(uniqueOwner, threadHandle, range) {
+        const commentController = this._commentControls.get(uniqueOwner);
         if (!commentController) {
             return;
         }
         await commentController.updateCommentThreadTemplate(threadHandle, range);
     }
-    disposeCommentThread(owner, threadId) {
-        const controller = this.getCommentController(owner);
+    disposeCommentThread(uniqueOwner, threadId) {
+        const controller = this.getCommentController(uniqueOwner);
         controller?.deleteCommentThreadMain(threadId);
     }
-    getCommentMenus(owner) {
-        if (this._commentMenus.get(owner)) {
-            return this._commentMenus.get(owner);
+    getCommentMenus(uniqueOwner) {
+        if (this._commentMenus.get(uniqueOwner)) {
+            return this._commentMenus.get(uniqueOwner);
         }
         const menu = this.instantiationService.createInstance(CommentMenus);
-        this._commentMenus.set(owner, menu);
+        this._commentMenus.set(uniqueOwner, menu);
         return menu;
     }
     updateComments(ownerId, event) {
         const control = this._commentControls.get(ownerId);
         if (control) {
-            const evt = Object.assign({}, event, { owner: ownerId, ownerLabel: control.label });
+            const evt = Object.assign({}, event, { uniqueOwner: ownerId, ownerLabel: control.label, owner: control.owner });
             this.updateModelThreads(evt);
         }
     }
     updateNotebookComments(ownerId, event) {
-        const evt = Object.assign({}, event, { owner: ownerId });
+        const evt = Object.assign({}, event, { uniqueOwner: ownerId });
         this._onDidUpdateNotebookCommentThreads.fire(evt);
     }
-    updateCommentingRanges(ownerId) {
+    updateCommentingRanges(ownerId, resourceHints) {
+        if (resourceHints?.schemes && resourceHints.schemes.length > 0) {
+            for (const scheme of resourceHints.schemes) {
+                this._commentingRangeResourceHintSchemes.add(scheme);
+            }
+        }
         this._workspaceHasCommenting.set(true);
-        this._onDidUpdateCommentingRanges.fire({ owner: ownerId });
+        this._onDidUpdateCommentingRanges.fire({ uniqueOwner: ownerId });
     }
-    async toggleReaction(owner, resource, thread, comment, reaction) {
-        const commentController = this._commentControls.get(owner);
+    async toggleReaction(uniqueOwner, resource, thread, comment, reaction) {
+        const commentController = this._commentControls.get(uniqueOwner);
         if (commentController) {
             return commentController.toggleReaction(resource, thread, comment, reaction, CancellationToken.None);
         }
@@ -234,8 +256,8 @@ let CommentService = class CommentService extends Disposable {
             throw new Error('Not supported');
         }
     }
-    hasReactionHandler(owner) {
-        const commentProvider = this._commentControls.get(owner);
+    hasReactionHandler(uniqueOwner) {
+        const commentProvider = this._commentControls.get(uniqueOwner);
         if (commentProvider) {
             return !!commentProvider.features.reactionHandler;
         }
@@ -248,10 +270,10 @@ let CommentService = class CommentService extends Disposable {
                 .then(documentComments => {
                 for (const documentCommentThread of documentComments.threads) {
                     if (documentCommentThread.comments?.length === 0 && documentCommentThread.range) {
-                        this.removeContinueOnComment({ range: documentCommentThread.range, uri: resource, owner: documentComments.owner });
+                        this.removeContinueOnComment({ range: documentCommentThread.range, uri: resource, uniqueOwner: documentComments.uniqueOwner });
                     }
                 }
-                const pendingComments = this._continueOnComments.get(documentComments.owner);
+                const pendingComments = this._continueOnComments.get(documentComments.uniqueOwner);
                 documentComments.pendingCommentThreads = pendingComments?.filter(pendingComment => ( pendingComment.uri.toString()) === ( resource.toString()));
                 return documentComments;
             })
@@ -259,7 +281,9 @@ let CommentService = class CommentService extends Disposable {
                 return null;
             }));
         }
-        return Promise.all(commentControlResult);
+        const commentInfos = await Promise.all(commentControlResult);
+        this._updateResourcesWithCommentingRanges(resource, commentInfos);
+        return commentInfos;
     }
     async getNotebookComments(resource) {
         const commentControlResult = [];
@@ -288,7 +312,7 @@ let CommentService = class CommentService extends Disposable {
         this.storageService.store(CONTINUE_ON_COMMENTS, commentsToSave, 1 , 0 );
     }
     removeContinueOnComment(pendingComment) {
-        const pendingComments = this._continueOnComments.get(pendingComment.owner);
+        const pendingComments = this._continueOnComments.get(pendingComment.uniqueOwner);
         if (pendingComments) {
             const commentIndex = pendingComments.findIndex(comment => ( comment.uri.toString()) === ( pendingComment.uri.toString()) && Range.equalsRange(comment.range, pendingComment.range) && (pendingComment.isReply === undefined || comment.isReply === pendingComment.isReply));
             if (commentIndex > -1) {
@@ -300,20 +324,23 @@ let CommentService = class CommentService extends Disposable {
     _addContinueOnComments(pendingComments, map) {
         const changedOwners = ( new Set());
         for (const pendingComment of pendingComments) {
-            if (!( map.has(pendingComment.owner))) {
-                map.set(pendingComment.owner, [pendingComment]);
-                changedOwners.add(pendingComment.owner);
+            if (!( map.has(pendingComment.uniqueOwner))) {
+                map.set(pendingComment.uniqueOwner, [pendingComment]);
+                changedOwners.add(pendingComment.uniqueOwner);
             }
             else {
-                const commentsForOwner = map.get(pendingComment.owner);
+                const commentsForOwner = map.get(pendingComment.uniqueOwner);
                 if (commentsForOwner.every(comment => (( comment.uri.toString()) !== ( pendingComment.uri.toString())) || !Range.equalsRange(comment.range, pendingComment.range))) {
                     commentsForOwner.push(pendingComment);
-                    changedOwners.add(pendingComment.owner);
+                    changedOwners.add(pendingComment.uniqueOwner);
                 }
             }
         }
         return changedOwners;
     }
+    resourceHasCommentingRanges(resource) {
+        return ( this._commentingRangeResourceHintSchemes.has(resource.scheme)) || ( this._commentingRangeResources.has(( resource.toString())));
+    }
 };
 CommentService = ( __decorate([
     ( __param(0, IInstantiationService)),
@@ -321,6 +348,7 @@ CommentService = ( __decorate([
     ( __param(2, IConfigurationService)),
     ( __param(3, IContextKeyService)),
     ( __param(4, IStorageService)),
-    ( __param(5, ILogService))
+    ( __param(5, ILogService)),
+    ( __param(6, IModelService))
 ], CommentService));
 export { CommentService, ICommentService };

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

@@ -10,7 +10,17 @@ import { CommentThreadBody } from './commentThreadBody.js';
 import { CommentThreadHeader } from './commentThreadHeader.js';
 import { CommentThreadAdditionalActions } from './commentThreadAdditionalActions.js';
 import { CommentContextKeys } from '../common/commentContextKeys.js';
-import { textLinkForeground, textLinkActiveForeground, focusBorder, textBlockQuoteBackground, textBlockQuoteBorder, contrastBorder, inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground } from '../../../../platform/theme/common/colorRegistry.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import { textLinkForeground, textLinkActiveForeground, focusBorder, textBlockQuoteBackground, textBlockQuoteBorder, contrastBorder } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import { inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground } from '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
 import { PANEL_BORDER } from '../../../common/theme.js';
 import { commentThreadStateColorVar, commentThreadStateBackgroundColorVar } from './commentColors.js';
 import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
@@ -248,7 +258,7 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
         }
     }
     focusCommentEditor() {
-        this._commentReply?.focusCommentEditor();
+        this._commentReply?.expandReplyAreaAndFocusCommentEditor();
     }
     focus() {
         this._body.focus();

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

@@ -20,6 +20,12 @@ import { StableEditorScrollState } from '../../../../editor/browser/stableEditor
 function getCommentThreadWidgetStateColor(thread, theme) {
     return getCommentThreadStateBorderColor(thread, theme) ?? theme.getColor(peekViewBorder);
 }
+var CommentWidgetFocus;
+( (function(CommentWidgetFocus) {
+    CommentWidgetFocus[CommentWidgetFocus["None"] = 0] = "None";
+    CommentWidgetFocus[CommentWidgetFocus["Widget"] = 1] = "Widget";
+    CommentWidgetFocus[CommentWidgetFocus["Editor"] = 2] = "Editor";
+})(CommentWidgetFocus || (CommentWidgetFocus = {})));
 function parseMouseDownInfoFromEvent(e) {
     const range = e.target.range;
     if (!range) {
@@ -50,8 +56,8 @@ function isMouseUpEventDragFromMouseDown(mouseDownInfo, e) {
     return lineNumber;
 }
 let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
-    get owner() {
-        return this._owner;
+    get uniqueOwner() {
+        return this._uniqueOwner;
     }
     get commentThread() {
         return this._commentThread;
@@ -59,9 +65,9 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
     get expanded() {
         return this._isExpanded;
     }
-    constructor(editor, _owner, _commentThread, _pendingComment, _pendingEdits, instantiationService, themeService, commentService, contextKeyService, configurationService) {
+    constructor(editor, _uniqueOwner, _commentThread, _pendingComment, _pendingEdits, instantiationService, themeService, commentService, contextKeyService, configurationService) {
         super(editor, { keepEditorSelection: true, isAccessible: true });
-        this._owner = _owner;
+        this._uniqueOwner = _uniqueOwner;
         this._commentThread = _commentThread;
         this._pendingComment = _pendingComment;
         this._pendingEdits = _pendingEdits;
@@ -74,7 +80,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
         this._commentThreadDisposables = [];
         this._contextKeyService = contextKeyService.createScoped(this.domNode);
         this._scopedInstantiationService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, this._contextKeyService])));
-        const controller = this.commentService.getCommentController(this._owner);
+        const controller = this.commentService.getCommentController(this._uniqueOwner);
         if (controller) {
             this._commentOptions = controller.options;
         }
@@ -108,7 +114,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
     }
     revealRange() {
     }
-    reveal(commentUniqueId, focus = false) {
+    reveal(commentUniqueId, focus = CommentWidgetFocus.None) {
         if (!this._isExpanded) {
             this.show(this.arrowPosition(this._commentThread.range), 2);
         }
@@ -123,16 +129,30 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
                     scrollTop = this.editor.getTopForLineNumber(this._commentThread.range.startLineNumber) - height / 2 + commentCoords.top - commentThreadCoords.top;
                 }
                 this.editor.setScrollTop(scrollTop);
-                if (focus) {
+                if (focus === CommentWidgetFocus.Widget) {
                     this._commentThreadWidget.focus();
                 }
+                else if (focus === CommentWidgetFocus.Editor) {
+                    this._commentThreadWidget.focusCommentEditor();
+                }
                 return;
             }
         }
-        this.editor.revealRangeInCenter(this._commentThread.range ?? ( new Range(1, 1, 1, 1)));
-        if (focus) {
+        const rangeToReveal = this._commentThread.range
+            ? ( new Range(
+            this._commentThread.range.startLineNumber,
+            this._commentThread.range.startColumn,
+            this._commentThread.range.endLineNumber + 1,
+            1
+        ))
+            : ( new Range(1, 1, 1, 1));
+        this.editor.revealRangeInCenter(rangeToReveal);
+        if (focus === CommentWidgetFocus.Widget) {
             this._commentThreadWidget.focus();
         }
+        else if (focus === CommentWidgetFocus.Editor) {
+            this._commentThreadWidget.focusCommentEditor();
+        }
     }
     getPendingComments() {
         return {
@@ -147,7 +167,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
     }
     _fillContainer(container) {
         this.setCssClass('review-widget');
-        this._commentThreadWidget = this._scopedInstantiationService.createInstance(CommentThreadWidget, container, this.editor, this._owner, this.editor.getModel().uri, this._contextKeyService, this._scopedInstantiationService, this._commentThread, this._pendingComment, this._pendingEdits, { editor: this.editor, codeBlockFontSize: '', codeBlockFontFamily: this.configurationService.getValue('editor').fontFamily || EDITOR_FONT_DEFAULTS.fontFamily }, this._commentOptions, {
+        this._commentThreadWidget = this._scopedInstantiationService.createInstance(CommentThreadWidget, container, this.editor, this._uniqueOwner, this.editor.getModel().uri, this._contextKeyService, this._scopedInstantiationService, this._commentThread, this._pendingComment, this._pendingEdits, { editor: this.editor, codeBlockFontSize: '', codeBlockFontFamily: this.configurationService.getValue('editor').fontFamily || EDITOR_FONT_DEFAULTS.fontFamily }, this._commentOptions, {
             actionRunner: async () => {
                 if (!this._commentThread.comments || !this._commentThread.comments.length) {
                     const newPosition = this.getPosition();
@@ -174,7 +194,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
                                 originalRange.endColumn
                             ));
                         }
-                        await this.commentService.updateCommentThreadTemplate(this.owner, this._commentThread.commentThreadHandle, range);
+                        await this.commentService.updateCommentThreadTemplate(this.uniqueOwner, this._commentThread.commentThreadHandle, range);
                     }
                 }
             },
@@ -192,7 +212,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
     }
     deleteCommentThread() {
         this.dispose();
-        this.commentService.disposeCommentThread(this.owner, this._commentThread.threadId);
+        this.commentService.disposeCommentThread(this.uniqueOwner, this._commentThread.threadId);
     }
     collapse() {
         this._commentThread.collapsibleState = CommentThreadCollapsibleState.Collapsed;
@@ -392,4 +412,4 @@ ReviewZoneWidget = ( __decorate([
     ( __param(8, IContextKeyService)),
     ( __param(9, IConfigurationService))
 ], ReviewZoneWidget));
-export { ReviewZoneWidget, isMouseUpEventDragFromMouseDown, parseMouseDownInfoFromEvent };
+export { CommentWidgetFocus, ReviewZoneWidget, isMouseUpEventDragFromMouseDown, parseMouseDownInfoFromEvent };