@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

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

@@ -0,0 +1,647 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Separator, ActionRunner, Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+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 { 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';
+import { ToolBar } from 'monaco-editor/esm/vs/base/browser/ui/toolbar/toolbar.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ToggleReactionsAction, ReactionAction, ReactionActionViewItem } from './reactionsAction.js';
+import { MenuItemAction, SubmenuItemAction, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { MenuEntryActionViewItem, SubmenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { CommentFormActions } from './commentFormActions.js';
+import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from 'monaco-editor/esm/vs/base/browser/ui/mouseCursor/mouseCursor.js';
+import { ActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { DropdownMenuActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/dropdown/dropdownActionViewItem.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { TimestampWidget } from './timestamp.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Scrollable } from 'monaco-editor/esm/vs/base/common/scrollable.js';
+import { SmoothScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+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);
+    }
+}
+let CommentNode = class CommentNode extends Disposable {
+    get domNode() {
+        return this._domNode;
+    }
+    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;
+        this.owner = owner;
+        this.resource = resource;
+        this.parentThread = parentThread;
+        this.markdownRenderer = markdownRenderer;
+        this.instantiationService = instantiationService;
+        this.commentService = commentService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        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());
+        this.isEditing = false;
+        this._domNode = dom.$('div.review-comment');
+        this._contextKeyService = contextKeyService.createScoped(this._domNode);
+        this._commentContextValue = CommentContextKeys.commentContext.bindTo(this._contextKeyService);
+        if (this.comment.contextValue) {
+            this._commentContextValue.set(this.comment.contextValue);
+        }
+        this._commentMenus = this.commentService.getCommentMenus(this.owner);
+        this._domNode.tabIndex = -1;
+        const avatar = dom.append(this._domNode, dom.$('div.avatar-container'));
+        if (comment.userIconPath) {
+            const img = dom.append(avatar, dom.$('img.avatar'));
+            img.src = ( FileAccess.uriToBrowserUri(URI.revive(comment.userIconPath)).toString(true));
+            img.onerror = _ => img.remove();
+        }
+        this._commentDetailsContainer = dom.append(this._domNode, dom.$('.review-comment-contents'));
+        this.createHeader(this._commentDetailsContainer);
+        this._body = document.createElement(`div`);
+        this._body.classList.add('comment-body', MOUSE_CURSOR_TEXT_CSS_CLASS_NAME);
+        if (configurationService.getValue(COMMENTS_SECTION)?.maxHeight !== false) {
+            this._body.classList.add('comment-body-max-height');
+        }
+        this.createScroll(this._commentDetailsContainer, this._body);
+        this.updateCommentBody(this.comment.body);
+        if (this.comment.commentReactions && this.comment.commentReactions.length && this.comment.commentReactions.filter(reaction => !!reaction.count).length) {
+            this.createReactionsContainer(this._commentDetailsContainer);
+        }
+        this._domNode.setAttribute('aria-label', `${comment.userName}, ${this.commentBodyValue}`);
+        this._domNode.setAttribute('role', 'treeitem');
+        this._clearTimeout = null;
+        this._register(dom.addDisposableListener(this._domNode, dom.EventType.CLICK, () => this.isEditing || this._onDidClick.fire(this)));
+        this._register(dom.addDisposableListener(this._domNode, dom.EventType.CONTEXT_MENU, e => {
+            return this.onContextMenu(e);
+        }));
+        if (pendingEdit) {
+            this.switchToEditMode();
+        }
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => {
+            this.toggleToolbarHidden(true);
+        }));
+    }
+    createScroll(container, body) {
+        this._scrollable = ( new Scrollable({
+            forceIntegerValues: true,
+            smoothScrollDuration: 125,
+            scheduleAtNextAnimationFrame: cb => dom.scheduleAtNextAnimationFrame(dom.getWindow(container), cb)
+        }));
+        this._scrollableElement = this._register(( new SmoothScrollableElement(body, {
+            horizontal: 3 ,
+            vertical: 3
+        }, this._scrollable)));
+        this._register(this._scrollableElement.onScroll(e => {
+            if (e.scrollLeftChanged) {
+                body.scrollLeft = e.scrollLeft;
+            }
+            if (e.scrollTopChanged) {
+                body.scrollTop = e.scrollTop;
+            }
+        }));
+        const onDidScrollViewContainer = this._register(( new DomEmitter(body, 'scroll'))).event;
+        this._register(onDidScrollViewContainer(_ => {
+            const position = this._scrollableElement.getScrollPosition();
+            const scrollLeft = Math.abs(body.scrollLeft - position.scrollLeft) <= 1 ? undefined : body.scrollLeft;
+            const scrollTop = Math.abs(body.scrollTop - position.scrollTop) <= 1 ? undefined : body.scrollTop;
+            if (scrollLeft !== undefined || scrollTop !== undefined) {
+                this._scrollableElement.setScrollPosition({ scrollLeft, scrollTop });
+            }
+        }));
+        container.appendChild(this._scrollableElement.getDomNode());
+    }
+    updateCommentBody(body) {
+        this._body.innerText = '';
+        this._md = undefined;
+        this._plainText = undefined;
+        if (typeof body === 'string') {
+            this._plainText = dom.append(this._body, dom.$('.comment-body-plainstring'));
+            this._plainText.innerText = body;
+        }
+        else {
+            this._md = this.markdownRenderer.render(body).element;
+            this._body.appendChild(this._md);
+        }
+    }
+    get onDidClick() {
+        return this._onDidClick.event;
+    }
+    createTimestamp(container) {
+        this._timestamp = dom.append(container, dom.$('span.timestamp-container'));
+        this.updateTimestamp(this.comment.timestamp);
+    }
+    updateTimestamp(raw) {
+        if (!this._timestamp) {
+            return;
+        }
+        const timestamp = raw !== undefined ? ( new Date(raw)) : undefined;
+        if (!timestamp) {
+            this._timestampWidget?.dispose();
+        }
+        else {
+            if (!this._timestampWidget) {
+                this._timestampWidget = ( new TimestampWidget(this.configurationService, this._timestamp, timestamp));
+                this._register(this._timestampWidget);
+            }
+            else {
+                this._timestampWidget.setTimestamp(timestamp);
+            }
+        }
+    }
+    createHeader(commentDetailsContainer) {
+        const header = dom.append(commentDetailsContainer, dom.$(`div.comment-title.${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`));
+        const infoContainer = dom.append(header, dom.$('comment-header-info'));
+        const author = dom.append(infoContainer, dom.$('strong.author'));
+        author.innerText = this.comment.userName;
+        this.createTimestamp(infoContainer);
+        this._isPendingLabel = dom.append(infoContainer, dom.$('span.isPending'));
+        if (this.comment.label) {
+            this._isPendingLabel.innerText = this.comment.label;
+        }
+        else {
+            this._isPendingLabel.innerText = '';
+        }
+        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 = [];
+        const secondary = [];
+        const result = { primary, secondary };
+        fillInActions(contributedActions, result, false, g => /^inline/.test(g));
+        return result;
+    }
+    get commentNodeContext() {
+        return [{
+                thread: this.commentThread,
+                commentUniqueId: this.comment.uniqueIdInThread,
+                $mid: 10
+            },
+            {
+                commentControlHandle: this.commentThread.controllerHandle,
+                commentThreadHandle: this.commentThread.commentThreadHandle,
+                $mid: 7
+            }];
+    }
+    createToolbar() {
+        this.toolbar = ( new ToolBar(this._actionsToolbarContainer, this.contextMenuService, {
+            actionViewItemProvider: action => {
+                if (action.id === ToggleReactionsAction.ID) {
+                    return ( new DropdownMenuActionViewItem(action, action.menuActions, this.contextMenuService, {
+                        actionViewItemProvider: action => this.actionViewItemProvider(action),
+                        actionRunner: this.actionRunner,
+                        classNames: ['toolbar-toggle-pickReactions', ...ThemeIcon.asClassNameArray(Codicon.reactions)],
+                        anchorAlignmentProvider: () => 1
+                    }));
+                }
+                return this.actionViewItemProvider(action);
+            },
+            orientation: 0
+        }));
+        this.toolbar.context = this.commentNodeContext;
+        this.toolbar.actionRunner = ( new CommentsActionRunner());
+        this.registerActionBarListeners(this._actionsToolbarContainer);
+        this._register(this.toolbar);
+    }
+    createActionsToolbar() {
+        const actions = [];
+        const hasReactionHandler = this.commentService.hasReactionHandler(this.owner);
+        if (hasReactionHandler) {
+            const toggleReactionAction = this.createReactionPicker(this.comment.commentReactions || []);
+            actions.push(toggleReactionAction);
+        }
+        const menu = this._commentMenus.getCommentTitleActions(this.comment, this._contextKeyService);
+        this._register(menu);
+        this._register(menu.onDidChange(e => {
+            const { primary, secondary } = this.getToolbarActions(menu);
+            if (!this.toolbar && (primary.length || secondary.length)) {
+                this.createToolbar();
+            }
+            this.toolbar.setActions(primary, secondary);
+        }));
+        const { primary, secondary } = this.getToolbarActions(menu);
+        actions.push(...primary);
+        if (actions.length || secondary.length) {
+            this.createToolbar();
+            this.toolbar.setActions(actions, secondary);
+        }
+    }
+    actionViewItemProvider(action) {
+        let options = {};
+        if (action.id === ToggleReactionsAction.ID) {
+            options = { label: false, icon: true };
+        }
+        else {
+            options = { label: false, icon: true };
+        }
+        if (action.id === ReactionAction.ID) {
+            const item = ( new ReactionActionViewItem(action));
+            return item;
+        }
+        else if (action instanceof MenuItemAction) {
+            return this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+        }
+        else if (action instanceof SubmenuItemAction) {
+            return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, undefined);
+        }
+        else {
+            const item = ( new ActionViewItem({}, action, options));
+            return item;
+        }
+    }
+    async submitComment() {
+        if (this._commentEditor && this._commentFormActions) {
+            await this._commentFormActions.triggerDefaultAction();
+            this.pendingEdit = undefined;
+        }
+    }
+    createReactionPicker(reactionGroup) {
+        const toggleReactionAction = this._register(( new ToggleReactionsAction(() => {
+            toggleReactionActionViewItem?.show();
+        }, ( nls.localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentNode',
+            'commentToggleReaction',
+            "Toggle Reaction"
+        )))));
+        let reactionMenuActions = [];
+        if (reactionGroup && reactionGroup.length) {
+            reactionMenuActions = ( reactionGroup.map((reaction) => {
+                return ( new Action(
+                    `reaction.command.${reaction.label}`,
+                    `${reaction.label}`,
+                    '',
+                    true,
+                    async () => {
+                        try {
+                            await this.commentService.toggleReaction(this.owner, this.resource, this.commentThread, this.comment, reaction);
+                        }
+                        catch (e) {
+                            const error = e.message
+                                ? ( nls.localizeWithPath(
+                                'vs/workbench/contrib/comments/browser/commentNode',
+                                'commentToggleReactionError',
+                                "Toggling the comment reaction failed: {0}.",
+                                e.message
+                            ))
+                                : ( nls.localizeWithPath(
+                                'vs/workbench/contrib/comments/browser/commentNode',
+                                'commentToggleReactionDefaultError',
+                                "Toggling the comment reaction failed"
+                            ));
+                            this.notificationService.error(error);
+                        }
+                    }
+                ));
+            }));
+        }
+        toggleReactionAction.menuActions = reactionMenuActions;
+        const toggleReactionActionViewItem = ( new DropdownMenuActionViewItem(
+            toggleReactionAction,
+            toggleReactionAction.menuActions,
+            this.contextMenuService,
+            {
+                actionViewItemProvider: action => {
+                    if (action.id === ToggleReactionsAction.ID) {
+                        return toggleReactionActionViewItem;
+                    }
+                    return this.actionViewItemProvider(action);
+                },
+                actionRunner: this.actionRunner,
+                classNames: 'toolbar-toggle-pickReactions',
+                anchorAlignmentProvider: () => 1
+            }
+        ));
+        return toggleReactionAction;
+    }
+    createReactionsContainer(commentDetailsContainer) {
+        this._reactionActionsContainer = dom.append(commentDetailsContainer, dom.$('div.comment-reactions'));
+        this._reactionsActionBar = ( new ActionBar(this._reactionActionsContainer, {
+            actionViewItemProvider: action => {
+                if (action.id === ToggleReactionsAction.ID) {
+                    return ( new DropdownMenuActionViewItem(action, action.menuActions, this.contextMenuService, {
+                        actionViewItemProvider: action => this.actionViewItemProvider(action),
+                        actionRunner: this.actionRunner,
+                        classNames: ['toolbar-toggle-pickReactions', ...ThemeIcon.asClassNameArray(Codicon.reactions)],
+                        anchorAlignmentProvider: () => 1
+                    }));
+                }
+                return this.actionViewItemProvider(action);
+            }
+        }));
+        this._register(this._reactionsActionBar);
+        const hasReactionHandler = this.commentService.hasReactionHandler(this.owner);
+        if (hasReactionHandler) {
+            const toggleReactionAction = this.createReactionPicker(this.comment.commentReactions || []);
+            this._reactionsActionBar.push(toggleReactionAction, { label: false, icon: true });
+        }
+    }
+    get commentBodyValue() {
+        return (typeof this.comment.body === 'string') ? this.comment.body : this.comment.body.value;
+    }
+    createCommentEditor(editContainer) {
+        const container = dom.append(editContainer, dom.$('.edit-textarea'));
+        this._commentEditor = this.instantiationService.createInstance(SimpleCommentEditor, container, SimpleCommentEditor.getEditorOptions(this.configurationService), this._contextKeyService, this.parentThread);
+        const resource = ( URI.parse(`comment:commentinput-${this.comment.uniqueIdInThread}-${Date.now()}.md`));
+        this._commentEditorModel = this.modelService.createModel('', this.languageService.createByFilepathOrFirstLine(resource), resource, false);
+        this._commentEditor.setModel(this._commentEditorModel);
+        this._commentEditor.setValue(this.pendingEdit ?? this.commentBodyValue);
+        this.pendingEdit = undefined;
+        this._commentEditor.layout({ width: container.clientWidth - 14, height: this._editorHeight });
+        this._commentEditor.focus();
+        dom.scheduleAtNextAnimationFrame(dom.getWindow(editContainer), () => {
+            this._commentEditor.layout({ width: container.clientWidth - 14, height: this._editorHeight });
+            this._commentEditor.focus();
+        });
+        const lastLine = this._commentEditorModel.getLineCount();
+        const lastColumn = this._commentEditorModel.getLineLength(lastLine) + 1;
+        this._commentEditor.setSelection(( new Selection(lastLine, lastColumn, lastLine, lastColumn)));
+        const commentThread = this.commentThread;
+        commentThread.input = {
+            uri: this._commentEditor.getModel().uri,
+            value: this.commentBodyValue
+        };
+        this.commentService.setActiveCommentThread(commentThread);
+        this._commentEditorDisposables.push(this._commentEditor.onDidFocusEditorWidget(() => {
+            commentThread.input = {
+                uri: this._commentEditor.getModel().uri,
+                value: this.commentBodyValue
+            };
+            this.commentService.setActiveCommentThread(commentThread);
+        }));
+        this._commentEditorDisposables.push(this._commentEditor.onDidChangeModelContent(e => {
+            if (commentThread.input && this._commentEditor && this._commentEditor.getModel().uri === commentThread.input.uri) {
+                const newVal = this._commentEditor.getValue();
+                if (newVal !== commentThread.input.value) {
+                    const input = commentThread.input;
+                    input.value = newVal;
+                    commentThread.input = input;
+                    this.commentService.setActiveCommentThread(commentThread);
+                }
+            }
+        }));
+        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) {
+            return model.getValue();
+        }
+        return undefined;
+    }
+    removeCommentEditor() {
+        this.isEditing = false;
+        if (this._editAction) {
+            this._editAction.enabled = true;
+        }
+        this._body.classList.remove('hidden');
+        this._commentEditorModel?.dispose();
+        this._commentEditorDisposables.forEach(dispose => dispose.dispose());
+        this._commentEditorDisposables = [];
+        if (this._commentEditor) {
+            this._commentEditor.dispose();
+            this._commentEditor = null;
+        }
+        this._commentEditContainer.remove();
+    }
+    layout(widthInPixel) {
+        const editorWidth = widthInPixel !== undefined ? widthInPixel - 72  : (this._commentEditor?.getLayoutInfo().width ?? 0);
+        this._commentEditor?.layout({ width: editorWidth, height: this._editorHeight });
+        const scrollWidth = this._body.scrollWidth;
+        const width = dom.getContentWidth(this._body);
+        const scrollHeight = this._body.scrollHeight;
+        const height = dom.getContentHeight(this._body) + 4;
+        this._scrollableElement.setScrollDimensions({ width, scrollWidth, height, scrollHeight });
+    }
+    switchToEditMode() {
+        if (this.isEditing) {
+            return;
+        }
+        this.isEditing = true;
+        this._body.classList.add('hidden');
+        this._commentEditContainer = dom.append(this._commentDetailsContainer, dom.$('.edit-container'));
+        this.createCommentEditor(this._commentEditContainer);
+        const formActions = dom.append(this._commentEditContainer, dom.$('.form-actions'));
+        const otherActions = dom.append(formActions, dom.$('.other-actions'));
+        this.createCommentWidgetFormActions(otherActions);
+        const editorActions = dom.append(formActions, dom.$('.editor-actions'));
+        this.createCommentWidgetEditorActions(editorActions);
+    }
+    createCommentWidgetFormActions(container) {
+        const menus = this.commentService.getCommentMenus(this.owner);
+        const menu = menus.getCommentActions(this.comment, this._contextKeyService);
+        this._register(menu);
+        this._register(menu.onDidChange(() => {
+            this._commentFormActions?.setActions(menu);
+        }));
+        this._commentFormActions = ( new CommentFormActions(container, (action) => {
+            const text = this._commentEditor.getValue();
+            action.run({
+                thread: this.commentThread,
+                commentUniqueId: this.comment.uniqueIdInThread,
+                text: text,
+                $mid: 11
+            });
+            this.removeCommentEditor();
+        }));
+        this._register(this._commentFormActions);
+        this._commentFormActions.setActions(menu);
+    }
+    createCommentWidgetEditorActions(container) {
+        const menus = this.commentService.getCommentMenus(this.owner);
+        const menu = menus.getCommentEditorActions(this._contextKeyService);
+        this._register(menu);
+        this._register(menu.onDidChange(() => {
+            this._commentEditorActions?.setActions(menu);
+        }));
+        this._commentEditorActions = ( new CommentFormActions(container, (action) => {
+            const text = this._commentEditor.getValue();
+            action.run({
+                thread: this.commentThread,
+                commentUniqueId: this.comment.uniqueIdInThread,
+                text: text,
+                $mid: 11
+            });
+            this._commentEditor?.focus();
+        }));
+        this._register(this._commentEditorActions);
+        this._commentEditorActions.setActions(menu, true);
+    }
+    setFocus(focused, visible = false) {
+        if (focused) {
+            this._domNode.focus();
+            this.toggleToolbarHidden(false);
+            this._actionsToolbarContainer.classList.add('tabfocused');
+            this._domNode.tabIndex = 0;
+            if (this.comment.mode === languages.CommentMode.Editing) {
+                this._commentEditor?.focus();
+            }
+        }
+        else {
+            if (this._actionsToolbarContainer.classList.contains('tabfocused') && !this._actionsToolbarContainer.classList.contains('mouseover')) {
+                this.toggleToolbarHidden(true);
+                this._domNode.tabIndex = -1;
+            }
+            this._actionsToolbarContainer.classList.remove('tabfocused');
+        }
+    }
+    registerActionBarListeners(actionsContainer) {
+        this._register(dom.addDisposableListener(this._domNode, 'mouseenter', () => {
+            this.toggleToolbarHidden(false);
+            actionsContainer.classList.add('mouseover');
+        }));
+        this._register(dom.addDisposableListener(this._domNode, 'mouseleave', () => {
+            if (actionsContainer.classList.contains('mouseover') && !actionsContainer.classList.contains('tabfocused')) {
+                this.toggleToolbarHidden(true);
+            }
+            actionsContainer.classList.remove('mouseover');
+        }));
+    }
+    update(newComment) {
+        if (newComment.body !== this.comment.body) {
+            this.updateCommentBody(newComment.body);
+        }
+        const isChangingMode = newComment.mode !== undefined && newComment.mode !== this.comment.mode;
+        this.comment = newComment;
+        if (isChangingMode) {
+            if (newComment.mode === languages.CommentMode.Editing) {
+                this.switchToEditMode();
+            }
+            else {
+                this.removeCommentEditor();
+            }
+        }
+        if (newComment.label) {
+            this._isPendingLabel.innerText = newComment.label;
+        }
+        else {
+            this._isPendingLabel.innerText = '';
+        }
+        this._reactionActionsContainer?.remove();
+        this._reactionsActionBar?.clear();
+        if (this.comment.commentReactions && ( this.comment.commentReactions.some(reaction => !!reaction.count))) {
+            this.createReactionsContainer(this._commentDetailsContainer);
+        }
+        if (this.comment.contextValue) {
+            this._commentContextValue.set(this.comment.contextValue);
+        }
+        else {
+            this._commentContextValue.reset();
+        }
+        if (this.comment.timestamp) {
+            this.updateTimestamp(this.comment.timestamp);
+        }
+    }
+    onContextMenu(e) {
+        const event = ( new StandardMouseEvent(dom.getWindow(this._domNode), e));
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => event,
+            menuId: MenuId.CommentThreadCommentContext,
+            menuActionOptions: { shouldForwardArgs: true },
+            contextKeyService: this._contextKeyService,
+            actionRunner: ( new CommentsActionRunner()),
+            getActionsContext: () => {
+                return this.commentNodeContext;
+            },
+        });
+    }
+    focus() {
+        this.domNode.focus();
+        if (!this._clearTimeout) {
+            this.domNode.classList.add('focus');
+            this._clearTimeout = setTimeout(() => {
+                this.domNode.classList.remove('focus');
+            }, 3000);
+        }
+    }
+};
+CommentNode = ( __decorate([
+    ( __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) {
+        let [group, actions] = tuple;
+        if (useAlternativeActions) {
+            actions = ( actions.map(a => (a instanceof MenuItemAction) && !!a.alt ? a.alt : a));
+        }
+        if (isPrimaryGroup(group)) {
+            const to = Array.isArray(target) ? target : target.primary;
+            to.unshift(...actions);
+        }
+        else {
+            const to = Array.isArray(target) ? target : target.secondary;
+            if (to.length > 0) {
+                to.push(( new Separator()));
+            }
+            to.push(...actions);
+        }
+    }
+}
+export { CommentNode };