@codingame/monaco-vscode-api 1.83.8 → 1.83.9

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

@@ -1,295 +0,0 @@
-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.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;
-    }
-    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) => {
-            this._actionRunDelegate?.();
-            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

@@ -1,60 +0,0 @@
-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

@@ -1,247 +0,0 @@
-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() {
-        this._commentElements.forEach(element => {
-            element.layout();
-        });
-    }
-    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) {
-        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();
-        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 };