@codingame/monaco-vscode-api 1.85.0 → 1.85.2

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

@@ -0,0 +1,300 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from 'monaco-editor/esm/vs/base/browser/ui/mouseCursor/mouseCursor.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { resolveColorValue, editorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/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';
+const COMMENT_SCHEME = 'comment';
+let INMEM_MODEL_ID = 0;
+const COMMENTEDITOR_DECORATION_KEY = 'commenteditordecoration';
+let CommentReply = class CommentReply extends Disposable {
+    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;
+        this._commentMenus = _commentMenus;
+        this._commentOptions = _commentOptions;
+        this._pendingComment = _pendingComment;
+        this._parentThread = _parentThread;
+        this._actionRunDelegate = _actionRunDelegate;
+        this.commentService = commentService;
+        this.languageService = languageService;
+        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);
+        this.commentEditorIsEmpty.set(!this._pendingComment);
+        const hasExistingComments = this._commentThread.comments && this._commentThread.comments.length > 0;
+        const modeId = generateUuid() + '-' + (hasExistingComments ? this._commentThread.threadId : ++INMEM_MODEL_ID);
+        const params = JSON.stringify({
+            extensionId: this._commentThread.extensionId,
+            commentThreadId: this._commentThread.threadId
+        });
+        let resource = ( URI.parse(
+            `${COMMENT_SCHEME}://${this._commentThread.extensionId}/commentinput-${modeId}.md?${params}`
+        ));
+        const commentController = this.commentService.getCommentController(owner);
+        if (commentController) {
+            resource = resource.with({ authority: commentController.id });
+        }
+        const model = this.modelService.createModel(this._pendingComment || '', this.languageService.createByFilepathOrFirstLine(resource), resource, false);
+        this._register(model);
+        this.commentEditor.setModel(model);
+        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();
+        if (hasExistingComments) {
+            this.createReplyButton(this.commentEditor, this.form);
+        }
+        else if ((this._commentThread.comments && this._commentThread.comments.length === 0) || this._pendingComment) {
+            this.expandReplyArea();
+        }
+        this._error = dom.append(this.form, dom.$('.validation-error.hidden'));
+        const formActions = dom.append(this.form, dom.$('.form-actions'));
+        this._formActions = dom.append(formActions, dom.$('.other-actions'));
+        this.createCommentWidgetFormActions(this._formActions, model);
+        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) {
+            this.createReplyButton(this.commentEditor, this.form);
+        }
+        if (this._commentThread.comments && this._commentThread.comments.length === 0) {
+            this.expandReplyArea();
+        }
+        if (isReplying) {
+            this.commentEditor.focus();
+        }
+    }
+    getPendingComment() {
+        const model = this.commentEditor.getModel();
+        if (model && model.getValueLength() > 0) {
+            return model.getValue();
+        }
+        return undefined;
+    }
+    setPendingComment(comment) {
+        this._pendingComment = comment;
+        this.expandReplyArea();
+        this.commentEditor.setValue(comment);
+    }
+    layout(widthInPixel) {
+        this.commentEditor.layout({ height: this._editorHeight, width: widthInPixel - 54  });
+    }
+    focusIfNeeded() {
+        if (!this._commentThread.comments || !this._commentThread.comments.length) {
+            this.commentEditor.focus();
+        }
+        else if (this.commentEditor.getModel().getValueLength() > 0) {
+            this.expandReplyArea();
+        }
+    }
+    focusCommentEditor() {
+        this.commentEditor.focus();
+    }
+    expandReplyAreaAndFocusCommentEditor() {
+        this.expandReplyArea();
+        this.commentEditor.focus();
+    }
+    isCommentEditorFocused() {
+        return this.commentEditor.hasWidgetFocus();
+    }
+    getCommentModel() {
+        return this.commentEditor.getModel();
+    }
+    updateCanReply() {
+        if (!this._commentThread.canReply) {
+            this.form.style.display = 'none';
+        }
+        else {
+            this.form.style.display = 'block';
+        }
+    }
+    async submitComment() {
+        await this._commentFormActions?.triggerDefaultAction();
+        this._pendingComment = undefined;
+    }
+    setCommentEditorDecorations() {
+        const model = this.commentEditor.getModel();
+        if (model) {
+            const valueLength = model.getValueLength();
+            const hasExistingComments = this._commentThread.comments && this._commentThread.comments.length > 0;
+            const placeholder = valueLength > 0
+                ? ''
+                : hasExistingComments
+                    ? (this._commentOptions?.placeHolder || ( nls.localizeWithPath('vs/workbench/contrib/comments/browser/commentReply', 'reply', "Reply...")))
+                    : (this._commentOptions?.placeHolder || ( nls.localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentReply',
+                'newComment',
+                "Type a new comment"
+            )));
+            const decorations = [{
+                    range: {
+                        startLineNumber: 0,
+                        endLineNumber: 0,
+                        startColumn: 0,
+                        endColumn: 1
+                    },
+                    renderOptions: {
+                        after: {
+                            contentText: placeholder,
+                            color: `${resolveColorValue(editorForeground, this.themeService.getColorTheme())?.transparent(0.4)}`
+                        }
+                    }
+                }];
+            this.commentEditor.setDecorationsByType('review-zone-widget', COMMENTEDITOR_DECORATION_KEY, decorations);
+        }
+    }
+    createTextModelListener(commentEditor, commentForm) {
+        this._commentThreadDisposables.push(commentEditor.onDidFocusEditorWidget(() => {
+            this._commentThread.input = {
+                uri: commentEditor.getModel().uri,
+                value: commentEditor.getValue()
+            };
+            this.commentService.setActiveCommentThread(this._commentThread);
+        }));
+        this._commentThreadDisposables.push(commentEditor.getModel().onDidChangeContent(() => {
+            const modelContent = commentEditor.getValue();
+            if (this._commentThread.input && this._commentThread.input.uri === commentEditor.getModel().uri && this._commentThread.input.value !== modelContent) {
+                const newInput = this._commentThread.input;
+                newInput.value = modelContent;
+                this._commentThread.input = newInput;
+            }
+            this.commentService.setActiveCommentThread(this._commentThread);
+        }));
+        this._commentThreadDisposables.push(this._commentThread.onDidChangeInput(input => {
+            const thread = this._commentThread;
+            const model = commentEditor.getModel();
+            if (thread.input && model && (thread.input.uri !== model.uri)) {
+                return;
+            }
+            if (!input) {
+                return;
+            }
+            if (commentEditor.getValue() !== input.value) {
+                commentEditor.setValue(input.value);
+                if (input.value === '') {
+                    this._pendingComment = '';
+                    commentForm.classList.remove('expand');
+                    commentEditor.getDomNode().style.outline = '';
+                    this._error.textContent = '';
+                    this._error.classList.add('hidden');
+                }
+            }
+        }));
+    }
+    createCommentWidgetFormActions(container, model) {
+        const menu = this._commentMenus.getCommentThreadActions(this._contextKeyService);
+        this._register(menu);
+        this._register(menu.onDidChange(() => {
+            this._commentFormActions.setActions(menu);
+        }));
+        this._commentFormActions = ( new CommentFormActions(container, async (action) => {
+            await this._actionRunDelegate?.();
+            await action.run({
+                thread: this._commentThread,
+                text: this.commentEditor.getValue(),
+                $mid: 9
+            });
+            this.hideReplyArea();
+        }));
+        this._register(this._commentFormActions);
+        this._commentFormActions.setActions(menu);
+    }
+    createCommentWidgetEditorActions(container, model) {
+        const editorMenu = this._commentMenus.getCommentEditorActions(this._contextKeyService);
+        this._register(editorMenu);
+        this._register(editorMenu.onDidChange(() => {
+            this._commentEditorActions.setActions(editorMenu);
+        }));
+        this._commentEditorActions = ( new CommentFormActions(container, async (action) => {
+            this._actionRunDelegate?.();
+            action.run({
+                thread: this._commentThread,
+                text: this.commentEditor.getValue(),
+                $mid: 9
+            });
+            this.focusCommentEditor();
+        }));
+        this._register(this._commentEditorActions);
+        this._commentEditorActions.setActions(editorMenu, true);
+    }
+    get isReplyExpanded() {
+        return this.form.classList.contains('expand');
+    }
+    expandReplyArea() {
+        if (!this.isReplyExpanded) {
+            this.form.classList.add('expand');
+            this.commentEditor.focus();
+            this.commentEditor.layout();
+        }
+    }
+    clearAndExpandReplyArea() {
+        if (!this.isReplyExpanded) {
+            this.commentEditor.setValue('');
+            this.expandReplyArea();
+        }
+    }
+    hideReplyArea() {
+        this.commentEditor.getDomNode().style.outline = '';
+        this.commentEditor.setValue('');
+        this._pendingComment = '';
+        this.form.classList.remove('expand');
+        this._error.textContent = '';
+        this._error.classList.add('hidden');
+    }
+    createReplyButton(commentEditor, commentForm) {
+        this._reviewThreadReplyButton = dom.append(commentForm, dom.$(`button.review-thread-reply-button.${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`));
+        this._reviewThreadReplyButton.title = this._commentOptions?.prompt || ( nls.localizeWithPath('vs/workbench/contrib/comments/browser/commentReply', 'reply', "Reply..."));
+        this._reviewThreadReplyButton.textContent = this._commentOptions?.prompt || ( nls.localizeWithPath('vs/workbench/contrib/comments/browser/commentReply', 'reply', "Reply..."));
+        this._register(dom.addDisposableListener(this._reviewThreadReplyButton, 'click', _ => this.clearAndExpandReplyArea()));
+        this._register(dom.addDisposableListener(this._reviewThreadReplyButton, 'focus', _ => this.clearAndExpandReplyArea()));
+        commentEditor.onDidBlurEditorWidget(() => {
+            if (commentEditor.getModel().getValueLength() === 0 && commentForm.classList.contains('expand')) {
+                commentForm.classList.remove('expand');
+            }
+        });
+    }
+};
+CommentReply = ( __decorate([
+    ( __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/commentThreadAdditionalActions.js

@@ -0,0 +1,60 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CommentFormActions } from './commentFormActions.js';
+class CommentThreadAdditionalActions extends Disposable {
+    constructor(container, _commentThread, _contextKeyService, _commentMenus, _actionRunDelegate) {
+        super();
+        this._commentThread = _commentThread;
+        this._contextKeyService = _contextKeyService;
+        this._commentMenus = _commentMenus;
+        this._actionRunDelegate = _actionRunDelegate;
+        this._container = dom.append(container, dom.$('.comment-additional-actions'));
+        dom.append(this._container, dom.$('.section-separator'));
+        this._buttonBar = dom.append(this._container, dom.$('.button-bar'));
+        this._createAdditionalActions(this._buttonBar);
+    }
+    _showMenu() {
+        this._container?.classList.remove('hidden');
+    }
+    _hideMenu() {
+        this._container?.classList.add('hidden');
+    }
+    _enableDisableMenu(menu) {
+        const groups = menu.getActions({ shouldForwardArgs: true });
+        for (const group of groups) {
+            const [, actions] = group;
+            for (const action of actions) {
+                if (action.enabled) {
+                    this._showMenu();
+                    return;
+                }
+                for (const subAction of action.actions ?? []) {
+                    if (subAction.enabled) {
+                        this._showMenu();
+                        return;
+                    }
+                }
+            }
+        }
+        this._hideMenu();
+    }
+    _createAdditionalActions(container) {
+        const menu = this._commentMenus.getCommentThreadAdditionalActions(this._contextKeyService);
+        this._register(menu);
+        this._register(menu.onDidChange(() => {
+            this._commentFormActions.setActions(menu,  true);
+            this._enableDisableMenu(menu);
+        }));
+        this._commentFormActions = ( new CommentFormActions(container, async (action) => {
+            this._actionRunDelegate?.();
+            action.run({
+                thread: this._commentThread,
+                $mid: 8
+            });
+        }, 4));
+        this._register(this._commentFormActions);
+        this._commentFormActions.setActions(menu,  true);
+        this._enableDisableMenu(menu);
+    }
+}
+export { CommentThreadAdditionalActions };

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

@@ -0,0 +1,249 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ICommentService } from './commentService.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { CommentNode } from './commentNode.js';
+import { MarkdownRenderer } from 'monaco-editor/esm/vs/editor/contrib/markdownRenderer/browser/markdownRenderer.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+let CommentThreadBody = class CommentThreadBody extends Disposable {
+    get length() {
+        return this._commentThread.comments ? this._commentThread.comments.length : 0;
+    }
+    get activeComment() {
+        return this._commentElements.filter(node => node.isEditing)[0];
+    }
+    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;
+        this._options = _options;
+        this._commentThread = _commentThread;
+        this._pendingEdits = _pendingEdits;
+        this._scopedInstatiationService = _scopedInstatiationService;
+        this._parentCommentThreadWidget = _parentCommentThreadWidget;
+        this.commentService = commentService;
+        this.openerService = openerService;
+        this.languageService = languageService;
+        this._commentElements = [];
+        this._focusedComment = undefined;
+        this._onDidResize = ( new Emitter());
+        this.onDidResize = this._onDidResize.event;
+        this._commentDisposable = ( new Map());
+        this._register(dom.addDisposableListener(container, dom.EventType.FOCUS_IN, e => {
+            this.commentService.setActiveCommentThread(this._commentThread);
+        }));
+        this._markdownRenderer = this._register(( new MarkdownRenderer(this._options, this.languageService, this.openerService)));
+    }
+    focus() {
+        this._commentsElement.focus();
+    }
+    display() {
+        this._commentsElement = dom.append(this.container, dom.$('div.comments-container'));
+        this._commentsElement.setAttribute('role', 'presentation');
+        this._commentsElement.tabIndex = 0;
+        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 )) && (!this._focusedComment || !this._commentElements[this._focusedComment].isEditing)) {
+                const moveFocusWithinBounds = (change) => {
+                    if (this._focusedComment === undefined && change >= 0) {
+                        return 0;
+                    }
+                    if (this._focusedComment === undefined && change < 0) {
+                        return this._commentElements.length - 1;
+                    }
+                    const newIndex = this._focusedComment + change;
+                    return Math.min(Math.max(0, newIndex), this._commentElements.length - 1);
+                };
+                this._setFocusedComment(event.equals(16 ) ? moveFocusWithinBounds(-1) : moveFocusWithinBounds(1));
+            }
+        }));
+        this._commentElements = [];
+        if (this._commentThread.comments) {
+            for (const comment of this._commentThread.comments) {
+                const newCommentNode = this.createNewCommentNode(comment);
+                this._commentElements.push(newCommentNode);
+                this._commentsElement.appendChild(newCommentNode.domNode);
+                if (comment.mode === languages.CommentMode.Editing) {
+                    newCommentNode.switchToEditMode();
+                }
+            }
+        }
+        this._resizeObserver = ( new MutationObserver(this._refresh.bind(this)));
+        this._resizeObserver.observe(this.container, {
+            attributes: true,
+            childList: true,
+            characterData: true,
+            subtree: true
+        });
+    }
+    _refresh() {
+        const dimensions = dom.getClientArea(this.container);
+        this._onDidResize.fire(dimensions);
+    }
+    getDimensions() {
+        return dom.getClientArea(this.container);
+    }
+    layout(widthInPixel) {
+        this._commentElements.forEach(element => {
+            element.layout(widthInPixel);
+        });
+    }
+    getPendingEdits() {
+        const pendingEdits = {};
+        this._commentElements.forEach(element => {
+            if (element.isEditing) {
+                const pendingEdit = element.getPendingEdit();
+                if (pendingEdit) {
+                    pendingEdits[element.comment.uniqueIdInThread] = pendingEdit;
+                }
+            }
+        });
+        return pendingEdits;
+    }
+    getCommentCoords(commentUniqueId) {
+        const matchedNode = this._commentElements.filter(commentNode => commentNode.comment.uniqueIdInThread === commentUniqueId);
+        if (matchedNode && matchedNode.length) {
+            const commentThreadCoords = dom.getDomNodePagePosition(this._commentElements[0].domNode);
+            const commentCoords = dom.getDomNodePagePosition(matchedNode[0].domNode);
+            return {
+                thread: commentThreadCoords,
+                comment: commentCoords
+            };
+        }
+        return;
+    }
+    updateCommentThread(commentThread, preserveFocus) {
+        const oldCommentsLen = this._commentElements.length;
+        const newCommentsLen = commentThread.comments ? commentThread.comments.length : 0;
+        const commentElementsToDel = [];
+        const commentElementsToDelIndex = [];
+        for (let i = 0; i < oldCommentsLen; i++) {
+            const comment = this._commentElements[i].comment;
+            const newComment = commentThread.comments ? commentThread.comments.filter(c => c.uniqueIdInThread === comment.uniqueIdInThread) : [];
+            if (newComment.length) {
+                this._commentElements[i].update(newComment[0]);
+            }
+            else {
+                commentElementsToDelIndex.push(i);
+                commentElementsToDel.push(this._commentElements[i]);
+            }
+        }
+        for (let i = commentElementsToDel.length - 1; i >= 0; i--) {
+            const commentToDelete = commentElementsToDel[i];
+            this._commentDisposable.get(commentToDelete)?.dispose();
+            this._commentDisposable.delete(commentToDelete);
+            this._commentElements.splice(commentElementsToDelIndex[i], 1);
+            this._commentsElement.removeChild(commentToDelete.domNode);
+        }
+        let lastCommentElement = null;
+        const newCommentNodeList = [];
+        const newCommentsInEditMode = [];
+        for (let i = newCommentsLen - 1; i >= 0; i--) {
+            const currentComment = commentThread.comments[i];
+            const oldCommentNode = this._commentElements.filter(commentNode => commentNode.comment.uniqueIdInThread === currentComment.uniqueIdInThread);
+            if (oldCommentNode.length) {
+                lastCommentElement = oldCommentNode[0].domNode;
+                newCommentNodeList.unshift(oldCommentNode[0]);
+            }
+            else {
+                const newElement = this.createNewCommentNode(currentComment);
+                newCommentNodeList.unshift(newElement);
+                if (lastCommentElement) {
+                    this._commentsElement.insertBefore(newElement.domNode, lastCommentElement);
+                    lastCommentElement = newElement.domNode;
+                }
+                else {
+                    this._commentsElement.appendChild(newElement.domNode);
+                    lastCommentElement = newElement.domNode;
+                }
+                if (currentComment.mode === languages.CommentMode.Editing) {
+                    newElement.switchToEditMode();
+                    newCommentsInEditMode.push(newElement);
+                }
+            }
+        }
+        this._commentThread = commentThread;
+        this._commentElements = newCommentNodeList;
+        if (newCommentsInEditMode.length) {
+            const lastIndex = this._commentElements.indexOf(newCommentsInEditMode[newCommentsInEditMode.length - 1]);
+            this._focusedComment = lastIndex;
+        }
+        this._updateAriaLabel();
+        if (!preserveFocus) {
+            this._setFocusedComment(this._focusedComment);
+        }
+    }
+    _updateAriaLabel() {
+        if (this._commentThread.isDocumentCommentThread()) {
+            if (this._commentThread.range) {
+                this._commentsElement.ariaLabel = ( nls.localizeWithPath(
+                    'vs/workbench/contrib/comments/browser/commentThreadBody',
+                    'commentThreadAria.withRange',
+                    "Comment thread with {0} comments on lines {1} through {2}. {3}.",
+                    this._commentThread.comments?.length,
+                    this._commentThread.range.startLineNumber,
+                    this._commentThread.range.endLineNumber,
+                    this._commentThread.label
+                ));
+            }
+            else {
+                this._commentsElement.ariaLabel = ( nls.localizeWithPath(
+                    'vs/workbench/contrib/comments/browser/commentThreadBody',
+                    'commentThreadAria.document',
+                    "Comment thread with {0} comments on the entire document. {1}.",
+                    this._commentThread.comments?.length,
+                    this._commentThread.label
+                ));
+            }
+        }
+        else {
+            this._commentsElement.ariaLabel = ( nls.localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentThreadBody',
+                'commentThreadAria',
+                "Comment thread with {0} comments. {1}.",
+                this._commentThread.comments?.length,
+                this._commentThread.label
+            ));
+        }
+    }
+    _setFocusedComment(value) {
+        if (this._focusedComment !== undefined) {
+            this._commentElements[this._focusedComment]?.setFocus(false);
+        }
+        if (this._commentElements.length === 0 || value === undefined) {
+            this._focusedComment = undefined;
+        }
+        else {
+            this._focusedComment = Math.min(value, this._commentElements.length - 1);
+            this._commentElements[this._focusedComment].setFocus(true);
+        }
+    }
+    createNewCommentNode(comment) {
+        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;
+    }
+    dispose() {
+        super.dispose();
+        if (this._resizeObserver) {
+            this._resizeObserver.disconnect();
+            this._resizeObserver = null;
+        }
+        this._commentDisposable.forEach(v => v.dispose());
+    }
+};
+CommentThreadBody = ( __decorate([
+    ( __param(9, ICommentService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, ILanguageService))
+], CommentThreadBody));
+export { CommentThreadBody };