@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

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

@@ -0,0 +1,109 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Action, ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+
+const collapseIcon = registerIcon('review-comment-collapse', Codicon.chevronUp, ( nls.localizeWithPath(
+    'vs/workbench/contrib/comments/browser/commentThreadHeader',
+    'collapseIcon',
+    'Icon to collapse a review comment.'
+)));
+const COLLAPSE_ACTION_CLASS = 'expand-review-action ' + ThemeIcon.asClassName(collapseIcon);
+class CommentThreadHeader extends Disposable {
+    constructor(container, _delegate, _commentMenus, _commentThread, _contextKeyService, instantiationService, _contextMenuService) {
+        super();
+        this._delegate = _delegate;
+        this._commentMenus = _commentMenus;
+        this._commentThread = _commentThread;
+        this._contextKeyService = _contextKeyService;
+        this.instantiationService = instantiationService;
+        this._contextMenuService = _contextMenuService;
+        this._headElement = dom.$('.head');
+        container.appendChild(this._headElement);
+        this._fillHead();
+    }
+    _fillHead() {
+        const titleElement = dom.append(this._headElement, dom.$('.review-title'));
+        this._headingLabel = dom.append(titleElement, dom.$('span.filename'));
+        this.createThreadLabel();
+        const actionsContainer = dom.append(this._headElement, dom.$('.review-actions'));
+        this._actionbarWidget = ( new ActionBar(actionsContainer, {
+            actionViewItemProvider: createActionViewItem.bind(undefined, this.instantiationService)
+        }));
+        this._register(this._actionbarWidget);
+        this._collapseAction = ( new Action('review.expand', ( nls.localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentThreadHeader',
+            'label.collapse',
+            "Collapse"
+        )), COLLAPSE_ACTION_CLASS, true, () => this._delegate.collapse()));
+        const menu = this._commentMenus.getCommentThreadTitleActions(this._contextKeyService);
+        this.setActionBarActions(menu);
+        this._register(menu);
+        this._register(menu.onDidChange(e => {
+            this.setActionBarActions(menu);
+        }));
+        this._register(dom.addDisposableListener(this._headElement, dom.EventType.CONTEXT_MENU, e => {
+            return this.onContextMenu(e);
+        }));
+        this._actionbarWidget.context = this._commentThread;
+    }
+    setActionBarActions(menu) {
+        const groups = menu.getActions({ shouldForwardArgs: true }).reduce((r, [, actions]) => [...r, ...actions], []);
+        this._actionbarWidget.clear();
+        this._actionbarWidget.push([...groups, this._collapseAction], { label: false, icon: true });
+    }
+    updateCommentThread(commentThread) {
+        this._commentThread = commentThread;
+        this._actionbarWidget.context = this._commentThread;
+        this.createThreadLabel();
+    }
+    createThreadLabel() {
+        let label;
+        label = this._commentThread.label;
+        if (label === undefined) {
+            if (!(this._commentThread.comments && this._commentThread.comments.length)) {
+                label = ( nls.localizeWithPath(
+                    'vs/workbench/contrib/comments/browser/commentThreadHeader',
+                    'startThread',
+                    "Start discussion"
+                ));
+            }
+        }
+        if (label) {
+            this._headingLabel.textContent = strings.escape(label);
+            this._headingLabel.setAttribute('aria-label', label);
+        }
+    }
+    updateHeight(headHeight) {
+        this._headElement.style.height = `${headHeight}px`;
+        this._headElement.style.lineHeight = this._headElement.style.height;
+    }
+    onContextMenu(e) {
+        const actions = ( this._commentMenus.getCommentThreadTitleContextActions(this._contextKeyService).getActions({ shouldForwardArgs: true }).map((value) => value[1])).flat();
+        if (!actions.length) {
+            return;
+        }
+        const event = ( new StandardMouseEvent(e));
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => event,
+            getActions: () => actions,
+            actionRunner: ( new ActionRunner()),
+            getActionsContext: () => {
+                return {
+                    commentControlHandle: this._commentThread.controllerHandle,
+                    commentThreadHandle: this._commentThread.commentThreadHandle,
+                    $mid: 7
+                };
+            },
+        });
+    }
+}
+
+export { CommentThreadHeader };

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

@@ -0,0 +1,109 @@
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { CommentThreadCollapsibleState } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+
+class CommentThreadRangeDecoration {
+    get id() {
+        return this._decorationId;
+    }
+    set id(id) {
+        this._decorationId = id;
+    }
+    constructor(range, options) {
+        this.range = range;
+        this.options = options;
+    }
+}
+class CommentThreadRangeDecorator extends Disposable {
+    static { this.description = 'comment-thread-range-decorator'; }
+    constructor(commentService) {
+        super();
+        this.decorationIds = [];
+        this.activeDecorationIds = [];
+        this.threadCollapseStateListeners = [];
+        const decorationOptions = {
+            description: CommentThreadRangeDecorator.description,
+            isWholeLine: false,
+            zIndex: 20,
+            className: 'comment-thread-range',
+            shouldFillLineOnLineBreak: true
+        };
+        this.decorationOptions = ModelDecorationOptions.createDynamic(decorationOptions);
+        const activeDecorationOptions = {
+            description: CommentThreadRangeDecorator.description,
+            isWholeLine: false,
+            zIndex: 20,
+            className: 'comment-thread-range-current',
+            shouldFillLineOnLineBreak: true
+        };
+        this.activeDecorationOptions = ModelDecorationOptions.createDynamic(activeDecorationOptions);
+        this._register(commentService.onDidChangeCurrentCommentThread(thread => {
+            this.updateCurrent(thread);
+        }));
+        this._register(commentService.onDidUpdateCommentThreads(() => {
+            this.updateCurrent(undefined);
+        }));
+    }
+    updateCurrent(thread) {
+        if (!this.editor || (thread?.resource && (thread.resource?.toString() !== this.editor.getModel()?.uri.toString()))) {
+            return;
+        }
+        this.currentThreadCollapseStateListener?.dispose();
+        const newDecoration = [];
+        if (thread) {
+            const range = thread.range;
+            if (range && !((range.startLineNumber === range.endLineNumber) && (range.startColumn === range.endColumn))) {
+                if (thread.collapsibleState === CommentThreadCollapsibleState.Expanded) {
+                    this.currentThreadCollapseStateListener = thread.onDidChangeCollapsibleState(state => {
+                        if (state === CommentThreadCollapsibleState.Collapsed) {
+                            this.updateCurrent(undefined);
+                        }
+                    });
+                    newDecoration.push(( new CommentThreadRangeDecoration(range, this.activeDecorationOptions)));
+                }
+            }
+        }
+        this.editor.changeDecorations((changeAccessor) => {
+            this.activeDecorationIds = changeAccessor.deltaDecorations(this.activeDecorationIds, newDecoration);
+            newDecoration.forEach((decoration, index) => decoration.id = this.decorationIds[index]);
+        });
+    }
+    update(editor, commentInfos) {
+        const model = editor?.getModel();
+        if (!editor || !model) {
+            return;
+        }
+        dispose(this.threadCollapseStateListeners);
+        this.editor = editor;
+        const commentThreadRangeDecorations = [];
+        for (const info of commentInfos) {
+            info.threads.forEach(thread => {
+                if (thread.isDisposed) {
+                    return;
+                }
+                const range = thread.range;
+                if (!range || (range.startLineNumber === range.endLineNumber) && (range.startColumn === range.endColumn)) {
+                    return;
+                }
+                this.threadCollapseStateListeners.push(thread.onDidChangeCollapsibleState(() => {
+                    this.update(editor, commentInfos);
+                }));
+                if (thread.collapsibleState === CommentThreadCollapsibleState.Collapsed) {
+                    return;
+                }
+                commentThreadRangeDecorations.push(( new CommentThreadRangeDecoration(range, this.decorationOptions)));
+            });
+        }
+        editor.changeDecorations((changeAccessor) => {
+            this.decorationIds = changeAccessor.deltaDecorations(this.decorationIds, commentThreadRangeDecorations);
+            commentThreadRangeDecorations.forEach((decoration, index) => decoration.id = this.decorationIds[index]);
+        });
+    }
+    dispose() {
+        dispose(this.threadCollapseStateListeners);
+        this.currentThreadCollapseStateListener?.dispose();
+        super.dispose();
+    }
+}
+
+export { CommentThreadRangeDecorator };

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

@@ -0,0 +1,331 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/review.css.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { CommentReply } from './commentReply.js';
+import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
+import { CommentThreadBody } from './commentThreadBody.js';
+import { CommentThreadHeader } from './commentThreadHeader.js';
+import { CommentThreadAdditionalActions } from './commentThreadAdditionalActions.js';
+import { CommentContextKeys } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentContextKeys';
+import { textLinkForeground, textLinkActiveForeground, focusBorder, textBlockQuoteBackground, textBlockQuoteBorder, contrastBorder, inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { PANEL_BORDER } from 'vscode/vscode/vs/workbench/common/theme';
+import { commentThreadStateColorVar, commentThreadStateBackgroundColorVar } from './commentColors.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { registerNavigableContainer } from 'vscode/vscode/vs/workbench/browser/actions/widgetNavigationCommands';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+
+let CommentThreadWidget = class CommentThreadWidget extends Disposable {
+    get commentThread() {
+        return this._commentThread;
+    }
+    constructor(container, _parentEditor, _owner, _parentResourceUri, _contextKeyService, _scopedInstantiationService, _commentThread, _pendingComment, _pendingEdits, _markdownOptions, _commentOptions, _containerDelegate, commentService, contextMenuService, configurationService, _keybindingService) {
+        super();
+        this.container = container;
+        this._parentEditor = _parentEditor;
+        this._owner = _owner;
+        this._parentResourceUri = _parentResourceUri;
+        this._contextKeyService = _contextKeyService;
+        this._scopedInstantiationService = _scopedInstantiationService;
+        this._commentThread = _commentThread;
+        this._pendingComment = _pendingComment;
+        this._pendingEdits = _pendingEdits;
+        this._markdownOptions = _markdownOptions;
+        this._commentOptions = _commentOptions;
+        this._containerDelegate = _containerDelegate;
+        this.commentService = commentService;
+        this.configurationService = configurationService;
+        this._keybindingService = _keybindingService;
+        this._commentThreadDisposables = [];
+        this._onDidResize = ( new Emitter());
+        this.onDidResize = this._onDidResize.event;
+        this._threadIsEmpty = CommentContextKeys.commentThreadIsEmpty.bindTo(this._contextKeyService);
+        this._threadIsEmpty.set(!_commentThread.comments || !_commentThread.comments.length);
+        this._focusedContextKey = CommentContextKeys.commentFocused.bindTo(this._contextKeyService);
+        this._commentMenus = this.commentService.getCommentMenus(this._owner);
+        this._header = ( new CommentThreadHeader(container, {
+            collapse: this.collapse.bind(this)
+        }, this._commentMenus, this._commentThread, this._contextKeyService, this._scopedInstantiationService, contextMenuService));
+        this._header.updateCommentThread(this._commentThread);
+        const bodyElement = dom.$('.body');
+        container.appendChild(bodyElement);
+        const tracker = this._register(dom.trackFocus(bodyElement));
+        this._register(registerNavigableContainer({
+            focusNotifiers: [tracker],
+            focusNextWidget: () => {
+                if (!this._commentReply?.isCommentEditorFocused()) {
+                    this._commentReply?.expandReplyAreaAndFocusCommentEditor();
+                }
+            },
+            focusPreviousWidget: () => {
+                if (this._commentReply?.isCommentEditorFocused() && this._commentThread.comments?.length) {
+                    this._body.focus();
+                }
+            }
+        }));
+        this._register(tracker.onDidFocus(() => this._focusedContextKey.set(true)));
+        this._register(tracker.onDidBlur(() => this._focusedContextKey.reset()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("accessibility.verbosity.comments" )) {
+                this._setAriaLabel();
+            }
+        }));
+        this._body = this._scopedInstantiationService.createInstance(CommentThreadBody, this._parentEditor, this._owner, this._parentResourceUri, bodyElement, this._markdownOptions, this._commentThread, this._pendingEdits, this._scopedInstantiationService, this);
+        this._register(this._body);
+        this._setAriaLabel();
+        this._styleElement = dom.createStyleSheet(this.container);
+        this._commentThreadContextValue = CommentContextKeys.commentThreadContext.bindTo(this._contextKeyService);
+        this._commentThreadContextValue.set(_commentThread.contextValue);
+        const commentControllerKey = CommentContextKeys.commentControllerContext.bindTo(this._contextKeyService);
+        const controller = this.commentService.getCommentController(this._owner);
+        if (controller?.contextValue) {
+            commentControllerKey.set(controller.contextValue);
+        }
+        this.currentThreadListeners();
+    }
+    _setAriaLabel() {
+        let ariaLabel = ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentThreadWidget',
+            'commentLabel',
+            "Comment"
+        ));
+        let keybinding;
+        const verbose = this.configurationService.getValue("accessibility.verbosity.comments" );
+        if (verbose) {
+            keybinding = this._keybindingService.lookupKeybinding("editor.action.accessibilityHelp" , this._contextKeyService)?.getLabel() ?? undefined;
+        }
+        if (keybinding) {
+            ariaLabel = ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentThreadWidget',
+                'commentLabelWithKeybinding',
+                "{0}, use ({1}) for accessibility help",
+                ariaLabel,
+                keybinding
+            ));
+        }
+        else {
+            ariaLabel = ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentThreadWidget',
+                'commentLabelWithKeybindingNoKeybinding',
+                "{0}, run the command Open Accessibility Help which is currently not triggerable via keybinding.",
+                ariaLabel
+            ));
+        }
+        this._body.container.ariaLabel = ariaLabel;
+    }
+    updateCurrentThread(hasMouse, hasFocus) {
+        if (hasMouse || hasFocus) {
+            this.commentService.setCurrentCommentThread(this.commentThread);
+        }
+        else {
+            this.commentService.setCurrentCommentThread(undefined);
+        }
+    }
+    currentThreadListeners() {
+        let hasMouse = false;
+        let hasFocus = false;
+        this._register(dom.addDisposableListener(this.container, dom.EventType.MOUSE_ENTER, (e) => {
+            if (e.toElement === this.container) {
+                hasMouse = true;
+                this.updateCurrentThread(hasMouse, hasFocus);
+            }
+        }, true));
+        this._register(dom.addDisposableListener(this.container, dom.EventType.MOUSE_LEAVE, (e) => {
+            if (e.fromElement === this.container) {
+                hasMouse = false;
+                this.updateCurrentThread(hasMouse, hasFocus);
+            }
+        }, true));
+        this._register(dom.addDisposableListener(this.container, dom.EventType.FOCUS_IN, () => {
+            hasFocus = true;
+            this.updateCurrentThread(hasMouse, hasFocus);
+        }, true));
+        this._register(dom.addDisposableListener(this.container, dom.EventType.FOCUS_OUT, () => {
+            hasFocus = false;
+            this.updateCurrentThread(hasMouse, hasFocus);
+        }, true));
+    }
+    updateCommentThread(commentThread) {
+        const shouldCollapse = (this._commentThread.collapsibleState === languages.CommentThreadCollapsibleState.Expanded) && (this._commentThreadState === languages.CommentThreadState.Unresolved)
+            && (commentThread.state === languages.CommentThreadState.Resolved);
+        this._commentThreadState = commentThread.state;
+        this._commentThread = commentThread;
+        dispose(this._commentThreadDisposables);
+        this._commentThreadDisposables = [];
+        this._bindCommentThreadListeners();
+        this._body.updateCommentThread(commentThread);
+        this._threadIsEmpty.set(!this._body.length);
+        this._header.updateCommentThread(commentThread);
+        this._commentReply?.updateCommentThread(commentThread);
+        if (this._commentThread.contextValue) {
+            this._commentThreadContextValue.set(this._commentThread.contextValue);
+        }
+        else {
+            this._commentThreadContextValue.reset();
+        }
+        if (shouldCollapse && this.configurationService.getValue(COMMENTS_SECTION).collapseOnResolve) {
+            this.collapse();
+        }
+    }
+    display(lineHeight) {
+        const headHeight = Math.max(23, Math.ceil(lineHeight * 1.2));
+        this._header.updateHeight(headHeight);
+        this._body.display();
+        if (this._commentThread.canReply) {
+            this._createCommentForm();
+        }
+        this._createAdditionalActions();
+        this._register(this._body.onDidResize(dimension => {
+            this._refresh(dimension);
+        }));
+        if (this._commentThread.canReply && this._commentReply) {
+            this._commentReply.focusIfNeeded();
+        }
+        this._bindCommentThreadListeners();
+    }
+    _refresh(dimension) {
+        this._body.layout();
+        this._onDidResize.fire(dimension);
+    }
+    dispose() {
+        super.dispose();
+        this.updateCurrentThread(false, false);
+    }
+    _bindCommentThreadListeners() {
+        this._commentThreadDisposables.push(this._commentThread.onDidChangeCanReply(() => {
+            if (this._commentReply) {
+                this._commentReply.updateCanReply();
+            }
+            else {
+                if (this._commentThread.canReply) {
+                    this._createCommentForm();
+                }
+            }
+        }));
+        this._commentThreadDisposables.push(this._commentThread.onDidChangeComments(async (_) => {
+            await this.updateCommentThread(this._commentThread);
+        }));
+        this._commentThreadDisposables.push(this._commentThread.onDidChangeLabel(_ => {
+            this._header.createThreadLabel();
+        }));
+    }
+    _createCommentForm() {
+        this._commentReply = this._scopedInstantiationService.createInstance(CommentReply, this._owner, this._body.container, this._parentEditor, this._commentThread, this._scopedInstantiationService, this._contextKeyService, this._commentMenus, this._commentOptions, this._pendingComment, this, this._containerDelegate.actionRunner);
+        this._register(this._commentReply);
+    }
+    _createAdditionalActions() {
+        this._additionalActions = this._scopedInstantiationService.createInstance(CommentThreadAdditionalActions, this._body.container, this._commentThread, this._contextKeyService, this._commentMenus, this._containerDelegate.actionRunner);
+        this._register(this._additionalActions);
+    }
+    getCommentCoords(commentUniqueId) {
+        return this._body.getCommentCoords(commentUniqueId);
+    }
+    getPendingEdits() {
+        return this._body.getPendingEdits();
+    }
+    getPendingComment() {
+        if (this._commentReply) {
+            return this._commentReply.getPendingComment();
+        }
+        return undefined;
+    }
+    getDimensions() {
+        return this._body.getDimensions();
+    }
+    layout(widthInPixel) {
+        this._body.layout();
+        if (widthInPixel !== undefined) {
+            this._commentReply?.layout(widthInPixel);
+        }
+    }
+    focusCommentEditor() {
+        this._commentReply?.focusCommentEditor();
+    }
+    focus() {
+        this._body.focus();
+    }
+    async submitComment() {
+        const activeComment = this._body.activeComment;
+        if (activeComment) {
+            return activeComment.submitComment();
+        }
+        else if ((this._commentReply?.getPendingComment()?.length ?? 0) > 0) {
+            return this._commentReply?.submitComment();
+        }
+    }
+    collapse() {
+        this._containerDelegate.collapse();
+    }
+    applyTheme(theme, fontInfo) {
+        const content = [];
+        content.push(`.monaco-editor .review-widget > .body { border-top: 1px solid var(${commentThreadStateColorVar}) }`);
+        content.push(`.monaco-editor .review-widget > .head { background-color: var(${commentThreadStateBackgroundColorVar}) }`);
+        const linkColor = theme.getColor(textLinkForeground);
+        if (linkColor) {
+            content.push(`.review-widget .body .comment-body a { color: ${linkColor} }`);
+        }
+        const linkActiveColor = theme.getColor(textLinkActiveForeground);
+        if (linkActiveColor) {
+            content.push(`.review-widget .body .comment-body a:hover, a:active { color: ${linkActiveColor} }`);
+        }
+        const focusColor = theme.getColor(focusBorder);
+        if (focusColor) {
+            content.push(`.review-widget .body .comment-body a:focus { outline: 1px solid ${focusColor}; }`);
+            content.push(`.review-widget .body .monaco-editor.focused { outline: 1px solid ${focusColor}; }`);
+        }
+        const blockQuoteBackground = theme.getColor(textBlockQuoteBackground);
+        if (blockQuoteBackground) {
+            content.push(`.review-widget .body .review-comment blockquote { background: ${blockQuoteBackground}; }`);
+        }
+        const blockQuoteBOrder = theme.getColor(textBlockQuoteBorder);
+        if (blockQuoteBOrder) {
+            content.push(`.review-widget .body .review-comment blockquote { border-color: ${blockQuoteBOrder}; }`);
+        }
+        const border = theme.getColor(PANEL_BORDER);
+        if (border) {
+            content.push(`.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label { border-color: ${border}; }`);
+        }
+        const hcBorder = theme.getColor(contrastBorder);
+        if (hcBorder) {
+            content.push(`.review-widget .body .comment-form .review-thread-reply-button { outline-color: ${hcBorder}; }`);
+            content.push(`.review-widget .body .monaco-editor { outline: 1px solid ${hcBorder}; }`);
+        }
+        const errorBorder = theme.getColor(inputValidationErrorBorder);
+        if (errorBorder) {
+            content.push(`.review-widget .validation-error { border: 1px solid ${errorBorder}; }`);
+        }
+        const errorBackground = theme.getColor(inputValidationErrorBackground);
+        if (errorBackground) {
+            content.push(`.review-widget .validation-error { background: ${errorBackground}; }`);
+        }
+        const errorForeground = theme.getColor(inputValidationErrorForeground);
+        if (errorForeground) {
+            content.push(`.review-widget .body .comment-form .validation-error { color: ${errorForeground}; }`);
+        }
+        const fontFamilyVar = '--comment-thread-editor-font-family';
+        const fontSizeVar = '--comment-thread-editor-font-size';
+        const fontWeightVar = '--comment-thread-editor-font-weight';
+        this.container?.style.setProperty(fontFamilyVar, fontInfo.fontFamily);
+        this.container?.style.setProperty(fontSizeVar, `${fontInfo.fontSize}px`);
+        this.container?.style.setProperty(fontWeightVar, fontInfo.fontWeight);
+        content.push(`.review-widget .body code {
+			font-family: var(${fontFamilyVar});
+			font-weight: var(${fontWeightVar});
+		}`);
+        this._styleElement.textContent = content.join('\n');
+        this._commentReply?.setCommentEditorDecorations();
+    }
+};
+CommentThreadWidget = ( __decorate([
+    ( __param(12, ICommentService)),
+    ( __param(13, IContextMenuService)),
+    ( __param(14, IConfigurationService)),
+    ( __param(15, IKeybindingService))
+], CommentThreadWidget));
+
+export { CommentThreadWidget };