@codingame/monaco-vscode-api 1.83.7 → 1.83.9

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

@@ -1,646 +0,0 @@
-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(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(() => {
-            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() {
-        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;
-        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(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 };