@codingame/monaco-vscode-api 1.82.6 → 1.83.1

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

@@ -0,0 +1,171 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { ctxCommentEditorFocused } from './simpleCommentEditor.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { IAccessibleViewService } from '../../accessibility/browser/accessibleView.js';
+import { AccessibilityHelpAction } from '../../accessibility/browser/accessibleViewActions.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { CommentContextKeys } from '../common/commentContextKeys.js';
+import { ToggleTabFocusModeAction } from 'monaco-editor/esm/vs/editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: 'comments',
+    order: 20,
+    title: ( nls.localize('commentsConfigurationTitle', "Comments")),
+    type: 'object',
+    properties: {
+        'comments.openPanel': {
+            enum: ['neverOpen', 'openOnSessionStart', 'openOnSessionStartWithComments'],
+            default: 'openOnSessionStartWithComments',
+            description: ( nls.localize('openComments', "Controls when the comments panel should open.")),
+            restricted: false,
+            markdownDeprecationMessage: ( nls.localize(
+                'comments.openPanel.deprecated',
+                "This setting is deprecated in favor of `comments.openView`."
+            ))
+        },
+        'comments.openView': {
+            enum: ['never', 'file', 'firstFile', 'firstFileUnresolved'],
+            enumDescriptions: [( nls.localize('comments.openView.never', "The comments view will never be opened.")), ( nls.localize(
+                'comments.openView.file',
+                "The comments view will open when a file with comments is active."
+            )), ( nls.localize(
+                'comments.openView.firstFile',
+                "If the comments view has not been opened yet during this session it will open the first time during a session that a file with comments is active."
+            )), ( nls.localize(
+                'comments.openView.firstFileUnresolved',
+                "If the comments view has not been opened yet during this session and the comment is not resolved, it will open the first time during a session that a file with comments is active."
+            ))],
+            default: 'firstFile',
+            description: ( nls.localize('comments.openView', "Controls when the comments view should open.")),
+            restricted: false
+        },
+        'comments.useRelativeTime': {
+            type: 'boolean',
+            default: true,
+            description: ( nls.localize(
+                'useRelativeTime',
+                "Determines if relative time will be used in comment timestamps (ex. '1 day ago')."
+            ))
+        },
+        'comments.visible': {
+            type: 'boolean',
+            default: true,
+            description: ( nls.localize(
+                'comments.visible',
+                "Controls the visibility of the comments bar and comment threads in editors that have commenting ranges and comments. Comments are still accessible via the Comments view and will cause commenting to be toggled on in the same way running the command \"Comments: Toggle Editor Commenting\" toggles comments."
+            ))
+        },
+        'comments.maxHeight': {
+            type: 'boolean',
+            default: true,
+            description: ( nls.localize(
+                'comments.maxHeight',
+                "Controls whether the comments widget scrolls or expands."
+            ))
+        },
+        'comments.collapseOnResolve': {
+            type: 'boolean',
+            default: true,
+            description: ( nls.localize(
+                'collapseOnResolve',
+                "Controls whether the comment thread should collapse when the thread is resolved."
+            ))
+        }
+    }
+});
+var CommentAccessibilityHelpNLS;
+( (function(CommentAccessibilityHelpNLS) {
+    CommentAccessibilityHelpNLS.intro = ( nls.localize(
+        'intro',
+        "The editor contains commentable range(s). Some useful commands include:"
+    ));
+    CommentAccessibilityHelpNLS.introWidget = ( nls.localize(
+        'introWidget',
+        "This widget contains a text area, for composition of new comments, and actions, that can be tabbed to once tab moves focus mode has been enabled ({0})."
+    ));
+    CommentAccessibilityHelpNLS.introWidgetNoKb = ( nls.localize(
+        'introWidgetNoKb',
+        "This widget contains a text area, for composition of new comments, and actions, that can be tabbed to once tab moves focus mode has been enabled with the command Toggle Tab Key Moves Focus, which is currently not triggerable via keybinding."
+    ));
+    CommentAccessibilityHelpNLS.commentCommands = ( nls.localize('commentCommands', "Some useful comment commands include:"));
+    CommentAccessibilityHelpNLS.escape = ( nls.localize('escape', "- Dismiss Comment (Escape)"));
+    CommentAccessibilityHelpNLS.nextRange = ( nls.localize('next', "- Go to Next Commenting Range ({0})"));
+    CommentAccessibilityHelpNLS.nextRangeNoKb = ( nls.localize(
+        'nextNoKb',
+        "- Go to Next Commenting Range, which is currently not triggerable via keybinding."
+    ));
+    CommentAccessibilityHelpNLS.previousRange = ( nls.localize('previous', "- Go to Previous Commenting Range ({0})"));
+    CommentAccessibilityHelpNLS.previousRangeNoKb = ( nls.localize(
+        'previousNoKb',
+        "- Go to Previous Commenting Range, which is currently not triggerable via keybinding."
+    ));
+    CommentAccessibilityHelpNLS.nextCommentThreadKb = ( nls.localize('nextCommentThreadKb', "- Go to Next Comment Thread ({0})"));
+    CommentAccessibilityHelpNLS.nextCommentThreadNoKb = ( nls.localize(
+        'nextCommentThreadNoKb',
+        "- Go to Next Comment Thread, which is currently not triggerable via keybinding."
+    ));
+    CommentAccessibilityHelpNLS.previousCommentThreadKb = ( nls.localize('previousCommentThreadKb', "- Go to Previous Comment Thread ({0})"));
+    CommentAccessibilityHelpNLS.previousCommentThreadNoKb = ( nls.localize(
+        'previousCommentThreadNoKb',
+        "- Go to Previous Comment Thread, which is currently not triggerable via keybinding."
+    ));
+    CommentAccessibilityHelpNLS.addComment = ( nls.localize('addComment', "- Add Comment ({0})"));
+    CommentAccessibilityHelpNLS.addCommentNoKb = ( nls.localize(
+        'addCommentNoKb',
+        "- Add Comment on Current Selection, which is currently not triggerable via keybinding."
+    ));
+    CommentAccessibilityHelpNLS.submitComment = ( nls.localize('submitComment', "- Submit Comment ({0})"));
+    CommentAccessibilityHelpNLS.submitCommentNoKb = ( nls.localize(
+        'submitCommentNoKb',
+        "- Submit Comment, accessible via tabbing, as it's currently not triggerable with a keybinding."
+    ));
+})(CommentAccessibilityHelpNLS || (CommentAccessibilityHelpNLS = {})));
+class CommentsAccessibilityHelpContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibilityHelpAction.addImplementation(110, 'comments', accessor => {
+            const instantiationService = accessor.get(IInstantiationService);
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            accessibleViewService.show(instantiationService.createInstance(CommentsAccessibilityHelpProvider));
+            return true;
+        }, ( ContextKeyExpr.or(ctxCommentEditorFocused, CommentContextKeys.commentFocused))));
+    }
+}
+let CommentsAccessibilityHelpProvider = class CommentsAccessibilityHelpProvider {
+    constructor(_keybindingService) {
+        this._keybindingService = _keybindingService;
+        this.verbositySettingKey = "accessibility.verbosity.comments" ;
+        this.options = { type: "help"  };
+    }
+    _descriptionForCommand(commandId, msg, noKbMsg) {
+        const kb = this._keybindingService.lookupKeybinding(commandId);
+        if (kb) {
+            return strings.format(msg, kb.getAriaLabel());
+        }
+        return strings.format(noKbMsg, commandId);
+    }
+    provideContent() {
+        this._element = document.activeElement;
+        const content = [];
+        content.push(this._descriptionForCommand(ToggleTabFocusModeAction.ID, CommentAccessibilityHelpNLS.introWidget, CommentAccessibilityHelpNLS.introWidgetNoKb) + '\n');
+        content.push(CommentAccessibilityHelpNLS.commentCommands);
+        content.push(CommentAccessibilityHelpNLS.escape);
+        content.push(this._descriptionForCommand("workbench.action.addComment" , CommentAccessibilityHelpNLS.addComment, CommentAccessibilityHelpNLS.addCommentNoKb));
+        content.push(this._descriptionForCommand("editor.action.submitComment" , CommentAccessibilityHelpNLS.submitComment, CommentAccessibilityHelpNLS.submitCommentNoKb));
+        content.push(this._descriptionForCommand("editor.action.nextCommentingRange" , CommentAccessibilityHelpNLS.nextRange, CommentAccessibilityHelpNLS.nextRangeNoKb));
+        content.push(this._descriptionForCommand("editor.action.previousCommentingRange" , CommentAccessibilityHelpNLS.previousRange, CommentAccessibilityHelpNLS.previousRangeNoKb));
+        return content.join('\n');
+    }
+    onClose() {
+        this._element?.focus();
+    }
+};
+CommentsAccessibilityHelpProvider = ( __decorate([
+    ( __param(0, IKeybindingService))
+], CommentsAccessibilityHelpProvider));
+export { CommentAccessibilityHelpNLS, CommentsAccessibilityHelpContribution, CommentsAccessibilityHelpProvider };

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

@@ -1,6 +1,7 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { coalesce, findFirstInSorted } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { findFirstIdxMonotonousOrArrLen } from 'monaco-editor/esm/vs/base/common/arraysFind.js';
 import { createCancelablePromise, Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
@@ -25,8 +26,12 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
 import { COMMENTEDITOR_DECORATION_KEY } from './commentReply.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { IContextKeyService, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { CommentThreadRangeDecorator } from './commentThreadRangeDecorator.js';
+import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { CommentContextKeys } from '../common/commentContextKeys.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
 const ID = 'editor.contrib.review';
 class CommentingRangeDecoration {
     get id() {
@@ -278,6 +283,15 @@ class CommentingRangeDecorator {
             this._onDidChangeDecorationsCount.fire(this.commentingRangeDecorations.length);
         }
     }
+    areRangesIntersectingOrTouchingByLine(a, b) {
+        if (a.endLineNumber < (b.startLineNumber - 1)) {
+            return false;
+        }
+        if ((b.endLineNumber + 1) < a.startLineNumber) {
+            return false;
+        }
+        return true;
+    }
     getMatchedCommentAction(commentRange) {
         if (commentRange === undefined) {
             const foundInfos = this._infos?.filter(info => info.commentingRanges.fileComments);
@@ -296,7 +310,7 @@ class CommentingRangeDecorator {
         const foundHoverActions = ( new Map());
         for (const decoration of this.commentingRangeDecorations) {
             const range = decoration.getActiveRange();
-            if (range && ((range.startLineNumber <= commentRange.startLineNumber) || (commentRange.endLineNumber <= range.endLineNumber))) {
+            if (range && this.areRangesIntersectingOrTouchingByLine(range, commentRange)) {
                 const action = decoration.getCommentAction();
                 const alreadyFoundInfo = foundHoverActions.get(action.ownerId);
                 if (alreadyFoundInfo?.action.commentingRangesInfo === action.commentingRangesInfo) {
@@ -317,19 +331,52 @@ class CommentingRangeDecorator {
             return (action.range.startLineNumber <= commentRange.startLineNumber) && (commentRange.endLineNumber <= action.range.endLineNumber);
         }).map(actions => actions.action));
     }
+    getNearestCommentingRange(findPosition, reverse) {
+        let findPositionContainedWithin;
+        let decorations;
+        if (reverse) {
+            decorations = [];
+            for (let i = this.commentingRangeDecorations.length - 1; i >= 0; i--) {
+                decorations.push(this.commentingRangeDecorations[i]);
+            }
+        }
+        else {
+            decorations = this.commentingRangeDecorations;
+        }
+        for (const decoration of decorations) {
+            const range = decoration.getActiveRange();
+            if (!range) {
+                continue;
+            }
+            if (findPositionContainedWithin && this.areRangesIntersectingOrTouchingByLine(range, findPositionContainedWithin)) {
+                findPositionContainedWithin = Range.plusRange(findPositionContainedWithin, range);
+                continue;
+            }
+            if (range.startLineNumber <= findPosition.lineNumber && findPosition.lineNumber <= range.endLineNumber) {
+                findPositionContainedWithin = ( new Range(
+                    range.startLineNumber,
+                    range.startColumn,
+                    range.endLineNumber,
+                    range.endColumn
+                ));
+                continue;
+            }
+            if (!reverse && range.endLineNumber < findPosition.lineNumber) {
+                continue;
+            }
+            if (reverse && range.startLineNumber > findPosition.lineNumber) {
+                continue;
+            }
+            return range;
+        }
+        return (decorations.length > 0 ? (decorations[0].getActiveRange() ?? undefined) : undefined);
+    }
     dispose() {
         this.commentingRangeDecorations = [];
     }
 }
-const ActiveCursorHasCommentingRange = ( new RawContextKey('activeCursorHasCommentingRange', false, {
-    description: ( nls.localize(
-        'hasCommentingRange',
-        "Whether the position at the active cursor has a commenting range"
-    )),
-    type: 'boolean'
-}));
 let CommentController = class CommentController {
-    constructor(editor, commentService, instantiationService, codeEditorService, contextMenuService, quickInputService, viewsService, configurationService, contextKeyService, editorService) {
+    constructor(editor, commentService, instantiationService, codeEditorService, contextMenuService, quickInputService, viewsService, configurationService, contextKeyService, editorService, keybindingService, accessibilityService) {
         this.commentService = commentService;
         this.instantiationService = instantiationService;
         this.codeEditorService = codeEditorService;
@@ -338,18 +385,22 @@ let CommentController = class CommentController {
         this.viewsService = viewsService;
         this.configurationService = configurationService;
         this.editorService = editorService;
+        this.keybindingService = keybindingService;
+        this.accessibilityService = accessibilityService;
         this.globalToDispose = ( new DisposableStore());
         this.localToDispose = ( new DisposableStore());
         this.mouseDownInfo = null;
         this._commentingRangeSpaceReserved = false;
         this._emptyThreadsToAddQueue = [];
         this._editorDisposables = [];
+        this._hasRespondedToEditorChange = false;
         this._commentInfos = [];
         this._commentWidgets = [];
         this._pendingNewCommentCache = {};
         this._pendingEditsCache = {};
         this._computePromise = null;
-        this._activeCursorHasCommentingRange = ActiveCursorHasCommentingRange.bindTo(contextKeyService);
+        this._activeCursorHasCommentingRange = CommentContextKeys.activeCursorHasCommentingRange.bindTo(contextKeyService);
+        this._activeEditorHasCommentingRange = CommentContextKeys.activeEditorHasCommentingRange.bindTo(contextKeyService);
         if (editor instanceof EmbeddedCodeEditorWidget) {
             return;
         }
@@ -375,8 +426,8 @@ let CommentController = class CommentController {
             }
             this.beginCompute();
         }));
-        this.globalToDispose.add(this.commentService.onDidSetDataProvider(_ => this.beginCompute()));
-        this.globalToDispose.add(this.commentService.onDidUpdateCommentingRanges(_ => this.beginCompute()));
+        this.globalToDispose.add(this.commentService.onDidSetDataProvider(_ => this.beginComputeAndHandleEditorChange()));
+        this.globalToDispose.add(this.commentService.onDidUpdateCommentingRanges(_ => this.beginComputeAndHandleEditorChange()));
         this.globalToDispose.add(this.commentService.onDidSetResourceCommentInfos(e => {
             const editorURI = this.editor && this.editor.hasModel() && this.editor.getModel().uri;
             if (editorURI && ( editorURI.toString()) === ( e.resource.toString())) {
@@ -405,7 +456,39 @@ let CommentController = class CommentController {
         }));
         this.onModelChanged();
         this.codeEditorService.registerDecorationType('comment-controller', COMMENTEDITOR_DECORATION_KEY, {});
-        this.beginCompute();
+        this.commentService.registerContinueOnCommentProvider({
+            provideContinueOnComments: () => {
+                const pendingComments = [];
+                if (this._commentWidgets) {
+                    for (const zone of this._commentWidgets) {
+                        const zonePendingComments = zone.getPendingComments();
+                        const pendingNewComment = zonePendingComments.newComment;
+                        if (!pendingNewComment || !zone.commentThread.range) {
+                            continue;
+                        }
+                        let lastCommentBody;
+                        if (zone.commentThread.comments && zone.commentThread.comments.length) {
+                            const lastComment = zone.commentThread.comments[zone.commentThread.comments.length - 1];
+                            if (typeof lastComment.body === 'string') {
+                                lastCommentBody = lastComment.body;
+                            }
+                            else {
+                                lastCommentBody = lastComment.body.value;
+                            }
+                        }
+                        if (pendingNewComment !== lastCommentBody) {
+                            pendingComments.push({
+                                owner: zone.owner,
+                                uri: zone.editor.getModel().uri,
+                                range: zone.commentThread.range,
+                                body: pendingNewComment
+                            });
+                        }
+                    }
+                }
+                return pendingComments;
+            }
+        });
     }
     registerEditorListeners() {
         this._editorDisposables = [];
@@ -505,20 +588,20 @@ let CommentController = class CommentController {
     static get(editor) {
         return editor.getContribution(ID);
     }
-    revealCommentThread(threadId, commentUniqueId, fetchOnceIfNotExist) {
+    revealCommentThread(threadId, commentUniqueId, fetchOnceIfNotExist, focus) {
         const commentThreadWidget = this._commentWidgets.filter(widget => widget.commentThread.threadId === threadId);
         if (commentThreadWidget.length === 1) {
-            commentThreadWidget[0].reveal(commentUniqueId);
+            commentThreadWidget[0].reveal(commentUniqueId, focus);
         }
         else if (fetchOnceIfNotExist) {
             if (this._computePromise) {
                 this._computePromise.then(_ => {
-                    this.revealCommentThread(threadId, commentUniqueId, false);
+                    this.revealCommentThread(threadId, commentUniqueId, false, focus);
                 });
             }
             else {
                 this.beginCompute().then(_ => {
-                    this.revealCommentThread(threadId, commentUniqueId, false);
+                    this.revealCommentThread(threadId, commentUniqueId, false, focus);
                 });
             }
         }
@@ -574,7 +657,7 @@ let CommentController = class CommentController {
             }
             return 0;
         });
-        const idx = findFirstInSorted(sortedWidgets, widget => {
+        const idx = findFirstIdxMonotonousOrArrLen(sortedWidgets, widget => {
             const lineValueOne = reverse ? after.lineNumber : (widget.commentThread.range?.startLineNumber ?? 0);
             const lineValueTwo = reverse ? (widget.commentThread.range?.startLineNumber ?? 0) : after.lineNumber;
             const columnValueOne = reverse ? after.column : (widget.commentThread.range?.startColumn ?? 0);
@@ -603,6 +686,37 @@ let CommentController = class CommentController {
     previousCommentThread() {
         this._findNearestCommentThread(true);
     }
+    _findNearestCommentingRange(reverse) {
+        if (!this.editor?.hasModel()) {
+            return;
+        }
+        const after = this.editor.getSelection().getEndPosition();
+        const range = this._commentingRangeDecorator.getNearestCommentingRange(after, reverse);
+        if (range) {
+            const position = reverse ? range.getEndPosition() : range.getStartPosition();
+            this.editor.setPosition(position);
+            this.editor.revealLineInCenterIfOutsideViewport(position.lineNumber);
+        }
+        if (this.accessibilityService.isScreenReaderOptimized()) {
+            const commentRangeStart = range?.getStartPosition().lineNumber;
+            const commentRangeEnd = range?.getEndPosition().lineNumber;
+            if (commentRangeStart && commentRangeEnd) {
+                const oneLine = commentRangeStart === commentRangeEnd;
+                oneLine ? status(( nls.localize('commentRange', "Line {0}", commentRangeStart))) : status(( nls.localize(
+                    'commentRangeStart',
+                    "Lines {0} to {1}",
+                    commentRangeStart,
+                    commentRangeEnd
+                )));
+            }
+        }
+    }
+    nextCommentingRange() {
+        this._findNearestCommentingRange();
+    }
+    previousCommentingRange() {
+        this._findNearestCommentingRange(true);
+    }
     dispose() {
         this.globalToDispose.dispose();
         this.localToDispose.dispose();
@@ -616,6 +730,7 @@ let CommentController = class CommentController {
         if (!this.editor) {
             return;
         }
+        this._hasRespondedToEditorChange = false;
         this.localToDispose.add(this.editor.onMouseDown(e => this.onEditorMouseDown(e)));
         this.localToDispose.add(this.editor.onMouseUp(e => this.onEditorMouseUp(e)));
         if (this._editorDisposables.length) {
@@ -644,9 +759,10 @@ let CommentController = class CommentController {
             if (!commentInfo || !commentInfo.length) {
                 return;
             }
-            const added = e.added.filter(thread => thread.resource && ( thread.resource.toString()) === ( editorURI.toString()));
-            const removed = e.removed.filter(thread => thread.resource && ( thread.resource.toString()) === ( editorURI.toString()));
-            const changed = e.changed.filter(thread => thread.resource && ( thread.resource.toString()) === ( editorURI.toString()));
+            const added = e.added.filter(thread => thread.resource && thread.resource === ( editorURI.toString()));
+            const removed = e.removed.filter(thread => thread.resource && thread.resource === ( editorURI.toString()));
+            const changed = e.changed.filter(thread => thread.resource && thread.resource === ( editorURI.toString()));
+            const pending = e.pending.filter(pending => ( pending.uri.toString()) === ( editorURI.toString()));
             removed.forEach(thread => {
                 const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.threadId === thread.threadId && zoneWidget.commentThread.threadId !== '');
                 if (matchedZones.length) {
@@ -681,22 +797,59 @@ let CommentController = class CommentController {
                     matchedNewCommentThreadZones[0].update(thread);
                     return;
                 }
-                const pendingCommentText = this._pendingNewCommentCache[e.owner] && this._pendingNewCommentCache[e.owner][thread.threadId];
+                const continueOnCommentText = (thread.range ? this.commentService.removeContinueOnComment({ owner: e.owner, uri: editorURI, range: thread.range })?.body : undefined);
+                const pendingCommentText = (this._pendingNewCommentCache[e.owner] && this._pendingNewCommentCache[e.owner][thread.threadId])
+                    ?? continueOnCommentText;
                 const pendingEdits = this._pendingEditsCache[e.owner] && this._pendingEditsCache[e.owner][thread.threadId];
                 this.displayCommentThread(e.owner, thread, pendingCommentText, pendingEdits);
                 this._commentInfos.filter(info => info.owner === e.owner)[0].threads.push(thread);
                 this.tryUpdateReservedSpace();
             });
+            pending.forEach(thread => {
+                this.commentService.createCommentThreadTemplate(thread.owner, thread.uri, Range.lift(thread.range));
+            });
             this._commentThreadRangeDecorator.update(this.editor, commentInfo);
         }));
-        this.beginCompute();
+        this.beginComputeAndHandleEditorChange();
+    }
+    beginComputeAndHandleEditorChange() {
+        this.beginCompute().then(() => {
+            if (!this._hasRespondedToEditorChange) {
+                if (( this._commentInfos.some(
+                    commentInfo => commentInfo.commentingRanges.ranges.length > 0 || commentInfo.commentingRanges.fileComments
+                ))) {
+                    this._hasRespondedToEditorChange = true;
+                    const verbose = this.configurationService.getValue("accessibility.verbosity.comments" );
+                    if (verbose) {
+                        const keybinding = this.keybindingService.lookupKeybinding("editor.action.accessibilityHelp" )?.getAriaLabel();
+                        if (keybinding) {
+                            status(( nls.localize(
+                                'hasCommentRangesKb',
+                                "Editor has commenting ranges, run the command Open Accessibility Help ({0}), for more information.",
+                                keybinding
+                            )));
+                        }
+                        else {
+                            status(( nls.localize(
+                                'hasCommentRangesNoKb',
+                                "Editor has commenting ranges, run the command Open Accessibility Help, which is currently not triggerable via keybinding, for more information."
+                            )));
+                        }
+                    }
+                    else {
+                        status(( nls.localize('hasCommentRanges', "Editor has commenting ranges.")));
+                    }
+                }
+            }
+        });
     }
     async openCommentsView(thread) {
         if (thread.comments && (thread.comments.length > 0)) {
-            if (this.configurationService.getValue(COMMENTS_SECTION).openView === 'file') {
+            const openViewState = this.configurationService.getValue(COMMENTS_SECTION).openView;
+            if (openViewState === 'file') {
                 return this.viewsService.openView(COMMENTS_VIEW_ID);
             }
-            else if (this.configurationService.getValue(COMMENTS_SECTION).openView === 'firstFile') {
+            else if (openViewState === 'firstFile' || (openViewState === 'firstFileUnresolved' && thread.state === languages.CommentThreadState.Unresolved)) {
                 const hasShownView = this.viewsService.getViewWithId(COMMENTS_VIEW_ID)?.hasRendered;
                 if (!hasShownView) {
                     return this.viewsService.openView(COMMENTS_VIEW_ID);
@@ -706,7 +859,7 @@ let CommentController = class CommentController {
         return undefined;
     }
     displayCommentThread(owner, thread, pendingComment, pendingEdits) {
-        if (!this.editor) {
+        if (!this.editor?.getModel()) {
             return;
         }
         if (this.isEditorInlineOriginal(this.editor)) {
@@ -791,6 +944,9 @@ let CommentController = class CommentController {
         const newCommentInfos = this._commentingRangeDecorator.getMatchedCommentAction(range);
         if (!newCommentInfos.length || !this.editor?.hasModel()) {
             this._addInProgress = false;
+            if (!newCommentInfos.length) {
+                throw new Error('There are no commenting ranges at the current position.');
+            }
             return Promise.resolve();
         }
         if (newCommentInfos.length > 1) {
@@ -855,7 +1011,7 @@ let CommentController = class CommentController {
         return;
     }
     getExistingCommentEditorOptions(editor) {
-        const lineDecorationsWidth = editor.getOption(64 );
+        const lineDecorationsWidth = editor.getOption(65 );
         let extraEditorClassName = [];
         const configuredExtraClassName = editor.getRawOptions().extraEditorClassName;
         if (configuredExtraClassName) {
@@ -870,7 +1026,7 @@ let CommentController = class CommentController {
             extraEditorClassName.splice(inlineCommentPos, 1);
         }
         const options = editor.getOptions();
-        if (options.get(42 ) && options.get(108 ) !== 'never') {
+        if (options.get(43 ) && options.get(109 ) !== 'never') {
             lineDecorationsWidth += 11;
         }
         lineDecorationsWidth -= 24;
@@ -879,7 +1035,7 @@ let CommentController = class CommentController {
     getWithCommentsEditorOptions(editor, extraEditorClassName, startingLineDecorationsWidth) {
         let lineDecorationsWidth = startingLineDecorationsWidth;
         const options = editor.getOptions();
-        if (options.get(42 ) && options.get(108 ) !== 'never') {
+        if (options.get(43 ) && options.get(109 ) !== 'never') {
             lineDecorationsWidth -= 11;
         }
         lineDecorationsWidth += 24;
@@ -920,7 +1076,11 @@ let CommentController = class CommentController {
         this._commentInfos = commentInfos;
         this.tryUpdateReservedSpace();
         this.removeCommentWidgetsAndStoreCache();
+        let hasCommentingRanges = false;
         this._commentInfos.forEach(info => {
+            if (!hasCommentingRanges && (info.commentingRanges.ranges.length > 0 || info.commentingRanges.fileComments)) {
+                hasCommentingRanges = true;
+            }
             const providerCacheStore = this._pendingNewCommentCache[info.owner];
             const providerEditsCacheStore = this._pendingEditsCache[info.owner];
             info.threads = info.threads.filter(thread => !thread.isDisposed);
@@ -938,9 +1098,18 @@ let CommentController = class CommentController {
                 }
                 this.displayCommentThread(info.owner, thread, pendingComment, pendingEdits);
             });
+            info.pendingCommentThreads?.forEach(thread => {
+                this.commentService.createCommentThreadTemplate(thread.owner, thread.uri, Range.lift(thread.range));
+            });
         });
         this._commentingRangeDecorator.update(this.editor, this._commentInfos);
         this._commentThreadRangeDecorator.update(this.editor, this._commentInfos);
+        if (hasCommentingRanges) {
+            this._activeEditorHasCommentingRange.set(true);
+        }
+        else {
+            this._activeEditorHasCommentingRange.set(false);
+        }
     }
     closeWidget() {
         this._commentWidgets?.forEach(widget => widget.hide());
@@ -1002,6 +1171,8 @@ CommentController = ( __decorate([
     ( __param(6, IViewsService)),
     ( __param(7, IConfigurationService)),
     ( __param(8, IContextKeyService)),
-    ( __param(9, IEditorService))
+    ( __param(9, IEditorService)),
+    ( __param(10, IKeybindingService)),
+    ( __param(11, IAccessibilityService))
 ], CommentController));
-export { ActiveCursorHasCommentingRange, CommentController, ID };
+export { CommentController, ID };

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

@@ -20,6 +20,7 @@ import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { openLinkFromMarkdown } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
 const COMMENTS_VIEW_ID = 'workbench.panel.comments';
 const COMMENTS_VIEW_STORAGE_ID = 'Comments';
+const COMMENTS_VIEW_ORIGINAL_TITLE = 'Comments';
 const COMMENTS_VIEW_TITLE = ( (nls.localize('comments.view.title', "Comments")));
 class CommentsModelVirualDelegate {
     static { this.RESOURCE_ID = 'resource-with-comments'; }
@@ -269,12 +270,7 @@ let CommentsList = class CommentsList extends WorkbenchObjectTree {
                     return '';
                 }
             },
-            expandOnlyOnTwistieClick: (element) => {
-                if (element instanceof CommentsModel || element instanceof ResourceWithCommentThreads) {
-                    return false;
-                }
-                return true;
-            },
+            expandOnlyOnTwistieClick: true,
             collapseByDefault: false,
             overrideStyles: options.overrideStyles,
             filter: options.filter,
@@ -304,4 +300,4 @@ CommentsList = ( (__decorate([
     ( (__param(6, IInstantiationService))),
     ( (__param(7, IConfigurationService)))
 ], CommentsList)));
-export { COMMENTS_VIEW_ID, COMMENTS_VIEW_STORAGE_ID, COMMENTS_VIEW_TITLE, CommentNodeRenderer, CommentsList, Filter, ResourceWithCommentsRenderer };
+export { COMMENTS_VIEW_ID, COMMENTS_VIEW_ORIGINAL_TITLE, COMMENTS_VIEW_STORAGE_ID, COMMENTS_VIEW_TITLE, CommentNodeRenderer, CommentsList, Filter, ResourceWithCommentsRenderer };

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

@@ -332,7 +332,7 @@ let CommentsPanel = class CommentsPanel extends FilterViewPane {
                 const commentToReveal = element instanceof ResourceWithCommentThreads ? element.commentThreads[0].comment.uniqueIdInThread : element.comment.uniqueIdInThread;
                 if (threadToReveal && isCodeEditor(editor)) {
                     const controller = CommentController.get(editor);
-                    controller?.revealCommentThread(threadToReveal, commentToReveal, true);
+                    controller?.revealCommentThread(threadToReveal, commentToReveal, true, !preserveFocus);
                 }
                 return true;
             }
@@ -351,7 +351,7 @@ let CommentsPanel = class CommentsPanel extends FilterViewPane {
                 const control = editor.getControl();
                 if (threadToReveal && isCodeEditor(control)) {
                     const controller = CommentController.get(control);
-                    controller?.revealCommentThread(threadToReveal, commentToReveal.uniqueIdInThread, true);
+                    controller?.revealCommentThread(threadToReveal, commentToReveal.uniqueIdInThread, true, !preserveFocus);
                 }
             }
         });