@codingame/monaco-vscode-api 1.82.6 → 1.83.0-next.0

package/vscode/src/vs/workbench/contrib/codeEditor/browser/toggleWordWrap.js

@@ -48,7 +48,7 @@ class ToggleWordWrapAction extends EditorAction {
             newState = null;
         }
         else {
-            const actualWrappingInfo = editor.getOption(143 );
+            const actualWrappingInfo = editor.getOption(144 );
             const wordWrapOverride = (actualWrappingInfo.wrappingColumn === -1 ? 'on' : 'off');
             newState = { wordWrapOverride };
         }
@@ -66,7 +66,7 @@ class ToggleWordWrapAction extends EditorAction {
     }
 }
 function findDiffEditorContainingCodeEditor(editor, codeEditorService) {
-    if (!editor.getOption(60 )) {
+    if (!editor.getOption(61 )) {
         return null;
     }
     for (const diffEditor of codeEditorService.listDiffEditors()) {
@@ -86,16 +86,16 @@ let ToggleWordWrapController = class ToggleWordWrapController extends Disposable
         this._contextKeyService = _contextKeyService;
         this._codeEditorService = _codeEditorService;
         const options = this._editor.getOptions();
-        const wrappingInfo = options.get(143 );
+        const wrappingInfo = options.get(144 );
         const isWordWrapMinified = this._contextKeyService.createKey(isWordWrapMinifiedKey, wrappingInfo.isWordWrapMinified);
         const isDominatedByLongLines = this._contextKeyService.createKey(isDominatedByLongLinesKey, wrappingInfo.isDominatedByLongLines);
         let currentlyApplyingEditorConfig = false;
         this._register(_editor.onDidChangeConfiguration((e) => {
-            if (!e.hasChanged(143 )) {
+            if (!e.hasChanged(144 )) {
                 return;
             }
             const options = this._editor.getOptions();
-            const wrappingInfo = options.get(143 );
+            const wrappingInfo = options.get(144 );
             isWordWrapMinified.set(wrappingInfo.isWordWrapMinified);
             isDominatedByLongLines.set(wrappingInfo.isDominatedByLongLines);
             if (!currentlyApplyingEditorConfig) {
@@ -178,7 +178,7 @@ function canToggleWordWrap(codeEditorService, editor) {
     if (model.uri.scheme === 'output') {
         return false;
     }
-    if (editor.getOption(60 )) {
+    if (editor.getOption(61 )) {
         for (const diffEditor of codeEditorService.listDiffEditors()) {
             if (diffEditor.getOriginalEditor() === editor && !diffEditor.renderSideBySide) {
                 return false;
@@ -211,7 +211,7 @@ let EditorWordWrapContextKeyTracker = class EditorWordWrapContextKeyTracker {
         if (activeEditor) {
             this._activeEditorListener.add(activeEditor.onDidChangeModel(() => this._updateFromCodeEditor()));
             this._activeEditorListener.add(activeEditor.onDidChangeConfiguration((e) => {
-                if (e.hasChanged(143 )) {
+                if (e.hasChanged(144 )) {
                     this._updateFromCodeEditor();
                 }
             }));
@@ -223,7 +223,7 @@ let EditorWordWrapContextKeyTracker = class EditorWordWrapContextKeyTracker {
             return this._setValues(false, false);
         }
         else {
-            const wrappingInfo = this._activeEditor.getOption(143 );
+            const wrappingInfo = this._activeEditor.getOption(144 );
             this._setValues(true, wrappingInfo.wrappingColumn !== -1);
         }
     }

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

@@ -10,7 +10,7 @@ import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { ICommentService } from './commentService.js';
-import { SimpleCommentEditor } from './simpleCommentEditor.js';
+import { MIN_EDITOR_HEIGHT, SimpleCommentEditor, calculateEditorHeight } from './simpleCommentEditor.js';
 import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -35,6 +35,7 @@ import { CommentContextKeys } from '../common/commentContextKeys.js';
 import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
 import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
 import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
 class CommentsActionRunner extends ActionRunner {
     async runAction(action, context) {
         await action.run(...context);
@@ -44,8 +45,9 @@ let CommentNode = class CommentNode extends Disposable {
     get domNode() {
         return this._domNode;
     }
-    constructor(commentThread, comment, pendingEdit, owner, resource, parentThread, markdownRenderer, instantiationService, commentService, modelService, languageService, notificationService, contextMenuService, contextKeyService, configurationService) {
+    constructor(parentEditor, commentThread, comment, pendingEdit, owner, resource, parentThread, markdownRenderer, instantiationService, commentService, modelService, languageService, notificationService, contextMenuService, contextKeyService, configurationService, accessibilityService) {
         super();
+        this.parentEditor = parentEditor;
         this.commentThread = commentThread;
         this.comment = comment;
         this.pendingEdit = pendingEdit;
@@ -60,11 +62,13 @@ let CommentNode = class CommentNode extends Disposable {
         this.notificationService = notificationService;
         this.contextMenuService = contextMenuService;
         this.configurationService = configurationService;
+        this.accessibilityService = accessibilityService;
         this._editAction = null;
         this._commentEditContainer = null;
         this._commentEditor = null;
         this._commentEditorDisposables = [];
         this._commentEditorModel = null;
+        this._editorHeight = MIN_EDITOR_HEIGHT;
         this._commentFormActions = null;
         this._commentEditorActions = null;
         this._onDidClick = ( new Emitter());
@@ -105,6 +109,9 @@ let CommentNode = class CommentNode extends Disposable {
         if (pendingEdit) {
             this.switchToEditMode();
         }
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => {
+            this.toggleToolbarHidden(true);
+        }));
     }
     createScroll(container, body) {
         this._scrollable = ( new Scrollable({
@@ -186,9 +193,18 @@ let CommentNode = class CommentNode extends Disposable {
         else {
             this._isPendingLabel.innerText = '';
         }
-        this._actionsToolbarContainer = dom.append(header, dom.$('.comment-actions.hidden'));
+        this._actionsToolbarContainer = dom.append(header, dom.$('.comment-actions'));
+        this.toggleToolbarHidden(true);
         this.createActionsToolbar();
     }
+    toggleToolbarHidden(hidden) {
+        if (hidden && !this.accessibilityService.isScreenReaderOptimized()) {
+            this._actionsToolbarContainer.classList.add('hidden');
+        }
+        else {
+            this._actionsToolbarContainer.classList.remove('hidden');
+        }
+    }
     getToolbarActions(menu) {
         const contributedActions = menu.getActions({ shouldForwardArgs: true });
         const primary = [];
@@ -277,7 +293,8 @@ let CommentNode = class CommentNode extends Disposable {
     }
     async submitComment() {
         if (this._commentEditor && this._commentFormActions) {
-            this._commentFormActions.triggerDefaultAction();
+            await this._commentFormActions.triggerDefaultAction();
+            this.pendingEdit = undefined;
         }
     }
     createReactionPicker(reactionGroup) {
@@ -365,14 +382,14 @@ let CommentNode = class CommentNode extends Disposable {
         this._commentEditor.setModel(this._commentEditorModel);
         this._commentEditor.setValue(this.pendingEdit ?? this.commentBodyValue);
         this.pendingEdit = undefined;
-        this._commentEditor.layout({ width: container.clientWidth - 14, height: 90 });
+        this._commentEditor.layout({ width: container.clientWidth - 14, height: this._editorHeight });
         this._commentEditor.focus();
         dom.scheduleAtNextAnimationFrame(() => {
-            this._commentEditor.layout({ width: container.clientWidth - 14, height: 90 });
+            this._commentEditor.layout({ width: container.clientWidth - 14, height: this._editorHeight });
             this._commentEditor.focus();
         });
         const lastLine = this._commentEditorModel.getLineCount();
-        const lastColumn = this._commentEditorModel.getLineContent(lastLine).length + 1;
+        const lastColumn = this._commentEditorModel.getLineLength(lastLine) + 1;
         this._commentEditor.setSelection(( new Selection(lastLine, lastColumn, lastLine, lastColumn)));
         const commentThread = this.commentThread;
         commentThread.input = {
@@ -398,9 +415,26 @@ let CommentNode = class CommentNode extends Disposable {
                 }
             }
         }));
+        this.calculateEditorHeight();
+        this._register((this._commentEditorModel.onDidChangeContent(() => {
+            if (this._commentEditor && this.calculateEditorHeight()) {
+                this._commentEditor.layout({ height: this._editorHeight, width: this._commentEditor.getLayoutInfo().width });
+                this._commentEditor.render(true);
+            }
+        })));
         this._register(this._commentEditor);
         this._register(this._commentEditorModel);
     }
+    calculateEditorHeight() {
+        if (this._commentEditor) {
+            const newEditorHeight = calculateEditorHeight(this.parentEditor, this._commentEditor, this._editorHeight);
+            if (newEditorHeight !== this._editorHeight) {
+                this._editorHeight = newEditorHeight;
+                return true;
+            }
+        }
+        return false;
+    }
     getPendingEdit() {
         const model = this._commentEditor?.getModel();
         if (model && model.getValueLength() > 0) {
@@ -424,7 +458,7 @@ let CommentNode = class CommentNode extends Disposable {
         this._commentEditContainer.remove();
     }
     layout() {
-        this._commentEditor?.layout();
+        this._commentEditor?.layout({ width: this._commentEditor.getLayoutInfo().width, height: this._editorHeight });
         const scrollWidth = this._body.scrollWidth;
         const width = dom.getContentWidth(this._body);
         const scrollHeight = this._body.scrollHeight;
@@ -488,7 +522,7 @@ let CommentNode = class CommentNode extends Disposable {
     setFocus(focused, visible = false) {
         if (focused) {
             this._domNode.focus();
-            this._actionsToolbarContainer.classList.remove('hidden');
+            this.toggleToolbarHidden(false);
             this._actionsToolbarContainer.classList.add('tabfocused');
             this._domNode.tabIndex = 0;
             if (this.comment.mode === languages.CommentMode.Editing) {
@@ -497,7 +531,7 @@ let CommentNode = class CommentNode extends Disposable {
         }
         else {
             if (this._actionsToolbarContainer.classList.contains('tabfocused') && !this._actionsToolbarContainer.classList.contains('mouseover')) {
-                this._actionsToolbarContainer.classList.add('hidden');
+                this.toggleToolbarHidden(true);
                 this._domNode.tabIndex = -1;
             }
             this._actionsToolbarContainer.classList.remove('tabfocused');
@@ -505,12 +539,12 @@ let CommentNode = class CommentNode extends Disposable {
     }
     registerActionBarListeners(actionsContainer) {
         this._register(dom.addDisposableListener(this._domNode, 'mouseenter', () => {
-            actionsContainer.classList.remove('hidden');
+            this.toggleToolbarHidden(false);
             actionsContainer.classList.add('mouseover');
         }));
         this._register(dom.addDisposableListener(this._domNode, 'mouseleave', () => {
             if (actionsContainer.classList.contains('mouseover') && !actionsContainer.classList.contains('tabfocused')) {
-                actionsContainer.classList.add('hidden');
+                this.toggleToolbarHidden(true);
             }
             actionsContainer.classList.remove('mouseover');
         }));
@@ -574,14 +608,15 @@ let CommentNode = class CommentNode extends Disposable {
     }
 };
 CommentNode = ( __decorate([
-    ( __param(7, IInstantiationService)),
-    ( __param(8, ICommentService)),
-    ( __param(9, IModelService)),
-    ( __param(10, ILanguageService)),
-    ( __param(11, INotificationService)),
-    ( __param(12, IContextMenuService)),
-    ( __param(13, IContextKeyService)),
-    ( __param(14, IConfigurationService))
+    ( __param(8, IInstantiationService)),
+    ( __param(9, ICommentService)),
+    ( __param(10, IModelService)),
+    ( __param(11, ILanguageService)),
+    ( __param(12, INotificationService)),
+    ( __param(13, IContextMenuService)),
+    ( __param(14, IContextKeyService)),
+    ( __param(15, IConfigurationService)),
+    ( __param(16, IAccessibilityService))
 ], CommentNode));
 function fillInActions(groups, target, useAlternativeActions, isPrimaryGroup = group => group === 'navigation') {
     for (const tuple of groups) {

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

@@ -13,14 +13,15 @@ import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeS
 import { CommentFormActions } from './commentFormActions.js';
 import { ICommentService } from './commentService.js';
 import { CommentContextKeys } from '../common/commentContextKeys.js';
-import { SimpleCommentEditor } from './simpleCommentEditor.js';
+import { MIN_EDITOR_HEIGHT, SimpleCommentEditor, calculateEditorHeight } from './simpleCommentEditor.js';
 const COMMENT_SCHEME = 'comment';
 let INMEM_MODEL_ID = 0;
 const COMMENTEDITOR_DECORATION_KEY = 'commenteditordecoration';
 let CommentReply = class CommentReply extends Disposable {
-    constructor(owner, container, _commentThread, _scopedInstatiationService, _contextKeyService, _commentMenus, _commentOptions, _pendingComment, _parentThread, _actionRunDelegate, commentService, languageService, modelService, themeService, configurationService) {
+    constructor(owner, container, _parentEditor, _commentThread, _scopedInstatiationService, _contextKeyService, _commentMenus, _commentOptions, _pendingComment, _parentThread, _actionRunDelegate, commentService, languageService, modelService, themeService, configurationService) {
         super();
         this.owner = owner;
+        this._parentEditor = _parentEditor;
         this._commentThread = _commentThread;
         this._scopedInstatiationService = _scopedInstatiationService;
         this._contextKeyService = _contextKeyService;
@@ -34,6 +35,7 @@ let CommentReply = class CommentReply extends Disposable {
         this.modelService = modelService;
         this.themeService = themeService;
         this._commentThreadDisposables = [];
+        this._editorHeight = MIN_EDITOR_HEIGHT;
         this.form = dom.append(container, dom.$('.comment-form'));
         this.commentEditor = this._register(this._scopedInstatiationService.createInstance(SimpleCommentEditor, this.form, SimpleCommentEditor.getEditorOptions(configurationService), _contextKeyService, this._parentThread));
         this.commentEditorIsEmpty = CommentContextKeys.commentIsEmpty.bindTo(this._contextKeyService);
@@ -54,9 +56,14 @@ let CommentReply = class CommentReply extends Disposable {
         const model = this.modelService.createModel(this._pendingComment || '', this.languageService.createByFilepathOrFirstLine(resource), resource, false);
         this._register(model);
         this.commentEditor.setModel(model);
-        this._register((this.commentEditor.getModel().onDidChangeContent(() => {
+        this.calculateEditorHeight();
+        this._register((model.onDidChangeContent(() => {
             this.setCommentEditorDecorations();
             this.commentEditorIsEmpty?.set(!this.commentEditor.getValue());
+            if (this.calculateEditorHeight()) {
+                this.commentEditor.layout({ height: this._editorHeight, width: this.commentEditor.getLayoutInfo().width });
+                this.commentEditor.render(true);
+            }
         })));
         this.createTextModelListener(this.commentEditor, this.form);
         this.setCommentEditorDecorations();
@@ -73,6 +80,14 @@ let CommentReply = class CommentReply extends Disposable {
         this._editorActions = dom.append(formActions, dom.$('.editor-actions'));
         this.createCommentWidgetEditorActions(this._editorActions, model);
     }
+    calculateEditorHeight() {
+        const newEditorHeight = calculateEditorHeight(this._parentEditor, this.commentEditor, this._editorHeight);
+        if (newEditorHeight !== this._editorHeight) {
+            this._editorHeight = newEditorHeight;
+            return true;
+        }
+        return false;
+    }
     updateCommentThread(commentThread) {
         const isReplying = this.commentEditor.hasTextFocus();
         if (!this._reviewThreadReplyButton) {
@@ -93,7 +108,7 @@ let CommentReply = class CommentReply extends Disposable {
         return undefined;
     }
     layout(widthInPixel) {
-        this.commentEditor.layout({ height: 5 * 18, width: widthInPixel - 54  });
+        this.commentEditor.layout({ height: this._editorHeight, width: widthInPixel - 54  });
     }
     focusIfNeeded() {
         if (!this._commentThread.comments || !this._commentThread.comments.length) {
@@ -125,7 +140,8 @@ let CommentReply = class CommentReply extends Disposable {
         }
     }
     async submitComment() {
-        return this._commentFormActions?.triggerDefaultAction();
+        await this._commentFormActions?.triggerDefaultAction();
+        this._pendingComment = undefined;
     }
     setCommentEditorDecorations() {
         const model = this.commentEditor.getModel();
@@ -266,10 +282,10 @@ let CommentReply = class CommentReply extends Disposable {
     }
 };
 CommentReply = ( __decorate([
-    ( __param(10, ICommentService)),
-    ( __param(11, ILanguageService)),
-    ( __param(12, IModelService)),
-    ( __param(13, IThemeService)),
-    ( __param(14, IConfigurationService))
+    ( __param(11, ICommentService)),
+    ( __param(12, ILanguageService)),
+    ( __param(13, IModelService)),
+    ( __param(14, IThemeService)),
+    ( __param(15, IConfigurationService))
 ], CommentReply));
 export { COMMENTEDITOR_DECORATION_KEY, CommentReply };

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

@@ -17,8 +17,9 @@ let CommentThreadBody = class CommentThreadBody extends Disposable {
     get activeComment() {
         return this._commentElements.filter(node => node.isEditing)[0];
     }
-    constructor(owner, parentResourceUri, container, _options, _commentThread, _pendingEdits, _scopedInstatiationService, _parentCommentThreadWidget, commentService, openerService, languageService) {
+    constructor(_parentEditor, owner, parentResourceUri, container, _options, _commentThread, _pendingEdits, _scopedInstatiationService, _parentCommentThreadWidget, commentService, openerService, languageService) {
         super();
+        this._parentEditor = _parentEditor;
         this.owner = owner;
         this.parentResourceUri = parentResourceUri;
         this.container = container;
@@ -50,7 +51,7 @@ let CommentThreadBody = class CommentThreadBody extends Disposable {
         this._updateAriaLabel();
         this._register(dom.addDisposableListener(this._commentsElement, dom.EventType.KEY_DOWN, (e) => {
             const event = ( new StandardKeyboardEvent(e));
-            if (event.equals(16 ) || event.equals(18 )) {
+            if ((event.equals(16 ) || event.equals(18 )) && (!this._focusedComment || !this._commentElements[this._focusedComment].isEditing)) {
                 const moveFocusWithinBounds = (change) => {
                     if (this._focusedComment === undefined && change >= 0) {
                         return 0;
@@ -221,7 +222,7 @@ let CommentThreadBody = class CommentThreadBody extends Disposable {
         }
     }
     createNewCommentNode(comment) {
-        const newCommentNode = this._scopedInstatiationService.createInstance(CommentNode, this._commentThread, comment, this._pendingEdits ? this._pendingEdits[comment.uniqueIdInThread] : undefined, this.owner, this.parentResourceUri, this._parentCommentThreadWidget, this._markdownRenderer);
+        const newCommentNode = this._scopedInstatiationService.createInstance(CommentNode, this._parentEditor, this._commentThread, comment, this._pendingEdits ? this._pendingEdits[comment.uniqueIdInThread] : undefined, this.owner, this.parentResourceUri, this._parentCommentThreadWidget, this._markdownRenderer);
         this._register(newCommentNode);
         this._commentDisposable.set(newCommentNode, newCommentNode.onDidClick(clickedNode => this._setFocusedComment(this._commentElements.findIndex(commentNode => commentNode.comment.uniqueIdInThread === clickedNode.comment.uniqueIdInThread))));
         return newCommentNode;
@@ -236,8 +237,8 @@ let CommentThreadBody = class CommentThreadBody extends Disposable {
     }
 };
 CommentThreadBody = ( __decorate([
-    ( __param(8, ICommentService)),
-    ( __param(9, IOpenerService)),
-    ( __param(10, ILanguageService))
+    ( __param(9, ICommentService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, ILanguageService))
 ], CommentThreadBody));
 export { CommentThreadBody };

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

@@ -3,6 +3,7 @@ import './media/review.css.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
 import { CommentReply } from './commentReply.js';
 import { ICommentService } from './commentService.js';
 import { CommentThreadBody } from './commentThreadBody.js';
@@ -14,17 +15,22 @@ import { PANEL_BORDER } from '../../../common/theme.js';
 import { commentThreadStateColorVar, commentThreadStateBackgroundColorVar } from './commentColors.js';
 import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
 import { registerNavigableContainer } from '../../../browser/actions/widgetNavigationCommands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 let CommentThreadWidget = class CommentThreadWidget extends Disposable {
     get commentThread() {
         return this._commentThread;
     }
-    constructor(container, _owner, _parentResourceUri, _contextKeyService, _scopedInstatiationService, _commentThread, _pendingComment, _pendingEdits, _markdownOptions, _commentOptions, _containerDelegate, commentService, contextMenuService) {
+    constructor(container, _parentEditor, _owner, _parentResourceUri, _contextKeyService, _scopedInstantiationService, _commentThread, _pendingComment, _pendingEdits, _markdownOptions, _commentOptions, _containerDelegate, commentService, contextMenuService, configurationService, _keybindingService) {
         super();
         this.container = container;
+        this._parentEditor = _parentEditor;
         this._owner = _owner;
         this._parentResourceUri = _parentResourceUri;
         this._contextKeyService = _contextKeyService;
-        this._scopedInstatiationService = _scopedInstatiationService;
+        this._scopedInstantiationService = _scopedInstantiationService;
         this._commentThread = _commentThread;
         this._pendingComment = _pendingComment;
         this._pendingEdits = _pendingEdits;
@@ -32,15 +38,18 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
         this._commentOptions = _commentOptions;
         this._containerDelegate = _containerDelegate;
         this.commentService = commentService;
+        this.configurationService = configurationService;
+        this._keybindingService = _keybindingService;
         this._commentThreadDisposables = [];
         this._onDidResize = ( new Emitter());
         this.onDidResize = this._onDidResize.event;
         this._threadIsEmpty = CommentContextKeys.commentThreadIsEmpty.bindTo(this._contextKeyService);
         this._threadIsEmpty.set(!_commentThread.comments || !_commentThread.comments.length);
+        this._focusedContextKey = CommentContextKeys.commentFocused.bindTo(this._contextKeyService);
         this._commentMenus = this.commentService.getCommentMenus(this._owner);
         this._header = ( new CommentThreadHeader(container, {
             collapse: this.collapse.bind(this)
-        }, this._commentMenus, this._commentThread, this._contextKeyService, this._scopedInstatiationService, contextMenuService));
+        }, this._commentMenus, this._commentThread, this._contextKeyService, this._scopedInstantiationService, contextMenuService));
         this._header.updateCommentThread(this._commentThread);
         const bodyElement = dom.$('.body');
         container.appendChild(bodyElement);
@@ -58,8 +67,16 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
                 }
             }
         }));
-        this._body = this._scopedInstatiationService.createInstance(CommentThreadBody, this._owner, this._parentResourceUri, bodyElement, this._markdownOptions, this._commentThread, this._pendingEdits, this._scopedInstatiationService, this);
+        this._register(tracker.onDidFocus(() => this._focusedContextKey.set(true)));
+        this._register(tracker.onDidBlur(() => this._focusedContextKey.reset()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("accessibility.verbosity.comments" )) {
+                this._setAriaLabel();
+            }
+        }));
+        this._body = this._scopedInstantiationService.createInstance(CommentThreadBody, this._parentEditor, this._owner, this._parentResourceUri, bodyElement, this._markdownOptions, this._commentThread, this._pendingEdits, this._scopedInstantiationService, this);
         this._register(this._body);
+        this._setAriaLabel();
         this._styleElement = dom.createStyleSheet(this.container);
         this._commentThreadContextValue = CommentContextKeys.commentThreadContext.bindTo(this._contextKeyService);
         this._commentThreadContextValue.set(_commentThread.contextValue);
@@ -70,6 +87,30 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
         }
         this.currentThreadListeners();
     }
+    _setAriaLabel() {
+        let ariaLabel = ( localize('commentLabel', "Comment"));
+        let keybinding;
+        const verbose = this.configurationService.getValue("accessibility.verbosity.comments" );
+        if (verbose) {
+            keybinding = this._keybindingService.lookupKeybinding("editor.action.accessibilityHelp" , this._contextKeyService)?.getLabel() ?? undefined;
+        }
+        if (keybinding) {
+            ariaLabel = ( localize(
+                'commentLabelWithKeybinding',
+                "{0}, use ({1}) for accessibility help",
+                ariaLabel,
+                keybinding
+            ));
+        }
+        else {
+            ariaLabel = ( localize(
+                'commentLabelWithKeybindingNoKeybinding',
+                "{0}, run the command Open Accessibility Help which is currently not triggerable via keybinding.",
+                ariaLabel
+            ));
+        }
+        this._body.container.ariaLabel = ariaLabel;
+    }
     updateCurrentThread(hasMouse, hasFocus) {
         if (hasMouse || hasFocus) {
             this.commentService.setCurrentCommentThread(this.commentThread);
@@ -103,6 +144,9 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
         }, true));
     }
     updateCommentThread(commentThread) {
+        const shouldCollapse = (this._commentThread.collapsibleState === languages.CommentThreadCollapsibleState.Expanded) && (this._commentThreadState === languages.CommentThreadState.Unresolved)
+            && (commentThread.state === languages.CommentThreadState.Resolved);
+        this._commentThreadState = commentThread.state;
         this._commentThread = commentThread;
         dispose(this._commentThreadDisposables);
         this._commentThreadDisposables = [];
@@ -117,9 +161,12 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
         else {
             this._commentThreadContextValue.reset();
         }
+        if (shouldCollapse && this.configurationService.getValue(COMMENTS_SECTION).collapseOnResolve) {
+            this.collapse();
+        }
     }
     display(lineHeight) {
-        const headHeight = Math.ceil(lineHeight * 1.2);
+        const headHeight = Math.max(23, Math.ceil(lineHeight * 1.2));
         this._header.updateHeight(headHeight);
         this._body.display();
         if (this._commentThread.canReply) {
@@ -161,11 +208,11 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
         }));
     }
     _createCommentForm() {
-        this._commentReply = this._scopedInstatiationService.createInstance(CommentReply, this._owner, this._body.container, this._commentThread, this._scopedInstatiationService, this._contextKeyService, this._commentMenus, this._commentOptions, this._pendingComment, this, this._containerDelegate.actionRunner);
+        this._commentReply = this._scopedInstantiationService.createInstance(CommentReply, this._owner, this._body.container, this._parentEditor, this._commentThread, this._scopedInstantiationService, this._contextKeyService, this._commentMenus, this._commentOptions, this._pendingComment, this, this._containerDelegate.actionRunner);
         this._register(this._commentReply);
     }
     _createAdditionalActions() {
-        this._additionalActions = this._scopedInstatiationService.createInstance(CommentThreadAdditionalActions, this._body.container, this._commentThread, this._contextKeyService, this._commentMenus, this._containerDelegate.actionRunner);
+        this._additionalActions = this._scopedInstantiationService.createInstance(CommentThreadAdditionalActions, this._body.container, this._commentThread, this._contextKeyService, this._commentMenus, this._containerDelegate.actionRunner);
         this._register(this._additionalActions);
     }
     getCommentCoords(commentUniqueId) {
@@ -268,7 +315,9 @@ let CommentThreadWidget = class CommentThreadWidget extends Disposable {
     }
 };
 CommentThreadWidget = ( __decorate([
-    ( __param(11, ICommentService)),
-    ( __param(12, IContextMenuService))
+    ( __param(12, ICommentService)),
+    ( __param(13, IContextMenuService)),
+    ( __param(14, IConfigurationService)),
+    ( __param(15, IKeybindingService))
 ], CommentThreadWidget));
 export { CommentThreadWidget };

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

@@ -83,7 +83,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
         this.create();
         this._globalToDispose.add(this.themeService.onDidColorThemeChange(this._applyTheme, this));
         this._globalToDispose.add(this.editor.onDidChangeConfiguration(e => {
-            if (e.hasChanged(49 )) {
+            if (e.hasChanged(50 )) {
                 this._applyTheme(this.themeService.getColorTheme());
             }
         }));
@@ -121,6 +121,9 @@ 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) {
+                    this._commentThreadWidget.focus();
+                }
                 return;
             }
         }
@@ -137,7 +140,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
     }
     _fillContainer(container) {
         this.setCssClass('review-widget');
-        this._commentThreadWidget = this._scopedInstantiationService.createInstance(CommentThreadWidget, container, 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._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, {
             actionRunner: () => {
                 if (!this._commentThread.comments || !this._commentThread.comments.length) {
                     const newPosition = this.getPosition();
@@ -242,7 +245,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
             this._commentGlyph = ( (new CommentGlyphWidget(this.editor, range?.endLineNumber ?? -1)));
             this._commentGlyph.setThreadState(this._commentThread.state);
         }
-        this._commentThreadWidget.display(this.editor.getOption(65 ));
+        this._commentThreadWidget.display(this.editor.getOption(66 ));
         this._disposables.add(this._commentThreadWidget.onDidResize(dimension => {
             this._refresh(dimension);
         }));
@@ -309,8 +312,8 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
         }
         if (this._isExpanded) {
             this._commentThreadWidget.layout();
-            const headHeight = Math.ceil(this.editor.getOption(65 ) * 1.2);
-            const lineHeight = this.editor.getOption(65 );
+            const headHeight = Math.ceil(this.editor.getOption(66 ) * 1.2);
+            const lineHeight = this.editor.getOption(66 );
             const arrowHeight = Math.round(lineHeight / 3);
             const frameThickness = Math.round(lineHeight / 9) * 2;
             const computedLinesNumber = Math.ceil(((headHeight + dimensions.height + arrowHeight + frameThickness + 8) ) / lineHeight);
@@ -333,7 +336,7 @@ let ReviewZoneWidget = class ReviewZoneWidget extends ZoneWidget {
             arrowColor: borderColor,
             frameColor: borderColor
         });
-        const fontInfo = this.editor.getOption(49 );
+        const fontInfo = this.editor.getOption(50 );
         this._commentThreadWidget.applyTheme(theme, fontInfo);
     }
     show(rangeOrPos, heightInLines) {