@codingame/monaco-vscode-api 1.85.0 → 1.85.2

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

@@ -0,0 +1,107 @@
+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(dom.getWindow(this._headElement), 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/commentThreadWidget.js

@@ -0,0 +1,333 @@
+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 './commentService.js';
+import { CommentThreadBody } from './commentThreadBody.js';
+import { CommentThreadHeader } from './commentThreadHeader.js';
+import { CommentThreadAdditionalActions } from './commentThreadAdditionalActions.js';
+import { CommentContextKeys } from '../common/commentContextKeys.js';
+import { textLinkForeground, textLinkActiveForeground, focusBorder, textBlockQuoteBackground, textBlockQuoteBorder, contrastBorder, inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { PANEL_BORDER } from '../../../common/theme.js';
+import { commentThreadStateColorVar, commentThreadStateBackgroundColorVar } from './commentColors.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { registerNavigableContainer } from '../../../browser/actions/widgetNavigationCommands.js';
+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._commentReply?.isCommentEditorFocused() ?? false);
+        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;
+    }
+    setPendingComment(comment) {
+        this._pendingComment = comment;
+        this._commentReply?.setPendingComment(comment);
+    }
+    getDimensions() {
+        return this._body.getDimensions();
+    }
+    layout(widthInPixel) {
+        this._body.layout(widthInPixel);
+        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 };

package/vscode/src/vs/workbench/contrib/comments/browser/media/review.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".review-widget{position:absolute;width:100%}.monaco-editor .review-widget{background-color:var(--vscode-peekViewResult-background)}.review-widget .hidden{display:none!important}.review-widget .body{overflow:hidden}.review-widget .body .review-comment{display:flex;padding:8px 16px 8px 20px}@keyframes monaco-review-widget-focus{0%{background:var(--vscode-peekViewResult-selectionBackground)}to{background:transparent}}.review-widget .body .review-comment.focus{animation:monaco-review-widget-focus 3s ease 0s}.review-widget .body .review-comment .comment-actions{margin-left:auto}.review-widget .body .review-comment .comment-actions .monaco-toolbar{height:22px}.review-widget .body .review-comment .comment-title .comment-header-info{overflow:hidden;text-overflow:ellipsis}.review-widget .body .review-comment .comment-title{display:flex;width:100%}.review-widget .body .review-comment .comment-title .action-label.codicon{line-height:18px}.review-widget .body .review-comment .comment-title .monaco-dropdown .toolbar-toggle-more{height:18px;line-height:18px;vertical-align:middle;width:16px}.review-widget .body .comment-body blockquote{border-left-style:solid;border-left-width:5px;margin:0 7px 0 5px;padding:0 16px 0 10px}.review-widget .body .review-comment .avatar-container{margin-top:4px!important}.review-widget .body .review-comment .avatar-container img.avatar{border-radius:3px;border-style:none;display:inline-block;height:28px;line-height:1;overflow:hidden;vertical-align:middle;width:28px}.review-widget .body .comment-reactions .monaco-text-button{background-color:transparent;border:1px solid grey;border-radius:3px;margin:0 7px 0 0;width:30px}.review-widget .body .review-comment .review-comment-contents{overflow:hidden;padding-left:20px;user-select:text;-webkit-user-select:text;width:100%}.review-widget .body pre{word-wrap:normal;overflow:auto;white-space:pre}.review-widget .body .review-comment .review-comment-contents .author{line-height:22px}.review-widget .body .review-comment .review-comment-contents .isPending{font-style:italic;line-height:22px;margin:0 5px;padding:0 2px}.review-widget .body .review-comment .review-comment-contents .timestamp{line-height:22px;margin:0 5px;padding:0 2px}.review-widget .body .review-comment .review-comment-contents .comment-body .comment-body-plainstring{white-space:pre-wrap}.review-widget .body .review-comment .review-comment-contents .comment-body{padding-top:4px}.review-widget .body .review-comment .review-comment-contents .comment-body-max-height{max-height:20em}.review-widget .body .review-comment .review-comment-contents .comment-reactions{margin-top:8px;min-height:25px}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item .action-label{display:flex;font-size:12px;padding:1px 4px;text-align:center;white-space:pre}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item .action-label .reaction-icon{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background-position:0;background-repeat:no-repeat;background-size:14px;display:inline-block;margin-right:4px;width:14px}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item .action-label .reaction-label{line-height:20px;margin-right:4px}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label.toolbar-toggle-pickReactions{background-position:50%;background-repeat:no-repeat;background-size:16px;border:none;display:none;font-size:16px;height:16px;margin-top:3px;width:26px}.review-widget .body .review-comment .review-comment-contents .comment-reactions:hover .action-item a.action-label.toolbar-toggle-pickReactions{background-size:16px;display:inline-block}.review-widget .body .review-comment .comment-title .action-label{background-position:50%;background-repeat:no-repeat;background-size:16px;display:block;height:16px;line-height:16px}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label{border:1px solid}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label.disabled{opacity:.6}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label.active:hover{background-color:var(--vscode-statusBarItem-hoverBackground)}.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label:active{background-color:var(--vscode-statusBarItem-activeBackground);border:1px solid transparent}.review-widget .body .review-comment .review-comment-contents a{cursor:pointer}.review-widget .body .comment-body p,.review-widget .body .comment-body ul{margin:8px 0}.review-widget .body .comment-body p:first-child,.review-widget .body .comment-body ul:first-child{margin-top:0}.review-widget .body .comment-body p:last-child,.review-widget .body.comment-body ul:last-child{margin-bottom:0}.review-widget .body .comment-body ul{padding-left:20px}.review-widget .body .comment-body li>p{margin-bottom:0}.review-widget .body .comment-body li>ul{margin-top:0}.review-widget .body .comment-body code{border-radius:3px;padding:0 .4em}.review-widget .body .comment-body span{white-space:pre}.review-widget .body .comment-body img{max-width:100%}.review-widget .body .comment-form{margin:8px 20px}.review-widget .validation-error{word-wrap:break-word;box-sizing:border-box;display:inline-block;font-size:12px;line-height:17px;margin-left:-1px;margin-top:-1px;min-height:34px;overflow:hidden;padding:.4em;text-align:left;width:100%}.review-widget .body .comment-additional-actions{margin:10px 20px}.review-widget .body .comment-additional-actions .section-separator{border-top:1px solid var(--vscode-menu-separatorBackground);margin:10px 0 14px}.review-widget .body .comment-additional-actions .button-bar{display:flex;white-space:nowrap}.review-widget .body .comment-additional-actions .monaco-button,.review-widget .body .comment-additional-actions .monaco-button-dropdown,.review-widget .body .comment-additional-actions .monaco-text-button{display:flex;width:auto}.review-widget .body .comment-additional-actions .button-bar>.monaco-button-dropdown,.review-widget .body .comment-additional-actions .button-bar>.monaco-text-button{margin:0 10px 0 0}.review-widget .body .comment-additional-actions .button-bar .monaco-text-button{padding:4px 10px}.review-widget .body .comment-additional-actions .codicon-drop-down-button{align-items:center}.review-widget .body .monaco-editor{color:var(--vscode-editor-foreground)}.review-widget .body .comment-form.expand .review-thread-reply-button{display:none}.review-widget .body .comment-form.expand .form-actions,.review-widget .body .comment-form.expand .monaco-editor{box-sizing:content-box;display:block}.review-widget .body .comment-form .review-thread-reply-button{background-color:var(--vscode-editorCommentsWidget-replyInputBackground);border:0;border-radius:0;box-sizing:border-box;color:var(--vscode-editor-foreground);display:block;font-family:var(--monaco-monospace-font);font-size:inherit;font-weight:600;line-height:20px;outline:1px solid transparent;padding:6px 12px;resize:vertical;text-align:left;white-space:nowrap;width:100%}.review-widget .body .comment-form .review-thread-reply-button:focus{outline-style:solid;outline-width:1px}.review-widget .body .comment-form .monaco-editor,.review-widget .body .comment-form .monaco-editor .monaco-editor-background,.review-widget .body .edit-container .monaco-editor .monaco-editor-background{background-color:var(--vscode-editorCommentsWidget-replyInputBackground)}.review-widget .body .comment-form .monaco-editor,.review-widget .body .edit-container .monaco-editor{border:0;border-radius:3px;box-sizing:content-box;max-height:500px;min-height:90px;padding:6px 0 6px 12px;width:100%}.review-widget .body .comment-form .form-actions,.review-widget .body .comment-form .monaco-editor{display:none}.review-widget .body .comment-form .form-actions,.review-widget .body .edit-container .form-actions{margin:10px 0;overflow:auto}.review-widget .body .edit-container .form-actions{padding-top:10px}.review-widget .body .edit-textarea{margin:5px 12px 10px 0}.review-widget .body .comment-form .monaco-text-button,.review-widget .body .edit-container .monaco-text-button{margin-left:5px;padding:4px 10px;width:auto}.review-widget .body .form-actions .monaco-text-button{float:right}.review-widget .head{box-sizing:border-box;display:flex;height:100%}.review-widget .head .review-title{cursor:default;display:inline-block;font-size:13px;margin-left:20px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.review-widget .head .review-title .dirname:not(:empty){font-size:.9em;margin-left:.5em}.review-widget .head .review-actions{flex:1;padding-right:2px;text-align:right}.review-widget .head .review-actions>.monaco-action-bar{display:inline-block}.review-widget .head .review-actions>.monaco-action-bar,.review-widget .head .review-actions>.monaco-action-bar>.actions-container{height:100%}.review-widget .action-item{margin-left:4px;min-height:20px;min-width:18px}.review-widget .head .review-actions>.monaco-action-bar .action-label{background-position:50%;background-repeat:no-repeat;line-height:inherit;margin:0}.review-widget .head .review-actions>.monaco-action-bar .action-label.codicon{margin:0}.review-widget>.body{border-top:1px solid;position:relative}.monaco-editor .comment-range-glyph{cursor:pointer;margin-left:10px;width:4px!important;z-index:10}div.preview.inline .monaco-editor .comment-range-glyph{display:none!important}.monaco-editor .comment-diff-added{border-left-style:solid;border-left-width:3px}.monaco-editor .comment-diff-added,.monaco-editor .comment-range-glyph.multiline-add{border-left-color:var(--vscode-editorGutter-commentRangeForeground)}.monaco-editor .comment-diff-added:before,.monaco-editor .comment-range-glyph.line-hover:before,.monaco-editor .comment-thread-unresolved:before,.monaco-editor .comment-thread:before{background:var(--vscode-editorGutter-commentRangeForeground)}.monaco-editor .comment-thread-range{background-color:var(--vscode-editorCommentsWidget-rangeBackground)}.monaco-editor .comment-thread-range-current{background-color:var(--vscode-editorCommentsWidget-rangeActiveBackground)}.monaco-editor .margin-view-overlays .comment-range-glyph.comment-thread,.monaco-editor .margin-view-overlays .comment-range-glyph.comment-thread-unresolved,.monaco-editor .margin-view-overlays .comment-range-glyph.line-hover{margin-left:13px}.monaco-editor .comment-range-glyph.comment-thread-unresolved:before,.monaco-editor .comment-range-glyph.comment-thread:before,.monaco-editor .margin-view-overlays .comment-range-glyph.line-hover:before,.monaco-editor .margin-view-overlays>div:hover>.comment-range-glyph.comment-diff-added:before{align-items:center;color:var(--vscode-editorGutter-commentGlyphForeground);display:flex;flex-direction:row;height:100%;justify-content:center;left:-6px;position:absolute;text-align:center;width:9px;z-index:10}.monaco-editor .comment-range-glyph.comment-thread-unresolved:before{color:var(--vscode-editorGutter-commentUnresolvedGlyphForeground)}.monaco-editor .margin-view-overlays .comment-range-glyph.multiline-add{border-left-style:dotted;border-left-width:3px;height:16px;margin-top:2px}.monaco-editor .margin-view-overlays .comment-range-glyph.line-hover:before,.monaco-editor .margin-view-overlays>div:hover>.comment-range-glyph.comment-diff-added:before{border-radius:3px;content:\"\\ea60\";font-family:codicon;margin-left:-5px;padding-left:1px;width:18px!important}.monaco-editor .comment-range-glyph.comment-thread,.monaco-editor .comment-range-glyph.comment-thread-unresolved{z-index:20}.monaco-editor .comment-range-glyph.comment-thread-unresolved:before,.monaco-editor .comment-range-glyph.comment-thread:before{border-radius:3px;font-family:codicon;font-size:13px;line-height:100%;margin-left:-5px;padding-left:1px;padding-top:1px;width:18px!important;z-index:20}.monaco-editor .comment-range-glyph.comment-thread:before{content:\"\\ea6b\"}.monaco-editor .comment-range-glyph.comment-thread-unresolved:before{content:\"\\ec0a\"}.monaco-editor.inline-comment .margin-view-overlays .codicon-folding-collapsed,.monaco-editor.inline-comment .margin-view-overlays .codicon-folding-expanded{margin-left:11px}.monaco-editor.inline-comment .margin-view-overlays .dirty-diff-glyph{margin-left:25px}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,99 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
+class ToggleReactionsAction extends Action {
+    static { this.ID = 'toolbar.toggle.pickReactions'; }
+    constructor(toggleDropdownMenu, title) {
+        super(ToggleReactionsAction.ID, title || ( nls.localizeWithPath(
+            'vs/workbench/contrib/comments/browser/reactionsAction',
+            'pickReactions',
+            "Pick Reactions..."
+        )), 'toggle-reactions', true);
+        this._menuActions = [];
+        this.toggleDropdownMenu = toggleDropdownMenu;
+    }
+    run() {
+        this.toggleDropdownMenu();
+        return Promise.resolve(true);
+    }
+    get menuActions() {
+        return this._menuActions;
+    }
+    set menuActions(actions) {
+        this._menuActions = actions;
+    }
+}
+class ReactionActionViewItem extends ActionViewItem {
+    constructor(action) {
+        super(null, action, {});
+    }
+    updateLabel() {
+        if (!this.label) {
+            return;
+        }
+        const action = this.action;
+        if (action.class) {
+            this.label.classList.add(action.class);
+        }
+        if (!action.icon) {
+            const reactionLabel = dom.append(this.label, dom.$('span.reaction-label'));
+            reactionLabel.innerText = action.label;
+        }
+        else {
+            const reactionIcon = dom.append(this.label, dom.$('.reaction-icon'));
+            const uri = URI.revive(action.icon);
+            reactionIcon.style.backgroundImage = dom.asCSSUrl(uri);
+            reactionIcon.title = action.label;
+        }
+        if (action.count) {
+            const reactionCount = dom.append(this.label, dom.$('span.reaction-count'));
+            reactionCount.innerText = `${action.count}`;
+        }
+    }
+    getTooltip() {
+        const action = this.action;
+        const toggleMessage = action.enabled ? ( nls.localizeWithPath(
+            'vs/workbench/contrib/comments/browser/reactionsAction',
+            'comment.toggleableReaction',
+            "Toggle reaction, "
+        )) : '';
+        if (action.count === undefined) {
+            return ( nls.localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
+                key: 'comment.reactionLabelNone', comment: [
+                    'This is a tooltip for an emoji button so that the current user can toggle their reaction to a comment.',
+                    'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second is the name of the reaction.'
+                ]
+            }, "{0}{1} reaction", toggleMessage, action.label));
+        }
+        else if (action.count === 1) {
+            return ( nls.localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
+                key: 'comment.reactionLabelOne', comment: [
+                    'This is a tooltip for an emoji that is a "reaction" to a comment where the count of the reactions is 1.',
+                    'The emoji is also a button so that the current user can also toggle their own emoji reaction.',
+                    'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second is the name of the reaction.'
+                ]
+            }, "{0}1 reaction with {1}", toggleMessage, action.label));
+        }
+        else if (action.count > 1) {
+            return ( nls.localizeWithPath('vs/workbench/contrib/comments/browser/reactionsAction', {
+                key: 'comment.reactionLabelMany', comment: [
+                    'This is a tooltip for an emoji that is a "reaction" to a comment where the count of the reactions is greater than 1.',
+                    'The emoji is also a button so that the current user can also toggle their own emoji reaction.',
+                    'The first arg is localized message "Toggle reaction" or empty if the user doesn\'t have permission to toggle the reaction, the second is number of users who have reacted with that reaction, and the third is the name of the reaction.'
+                ]
+            }, "{0}{1} reactions with {2}", toggleMessage, action.count, action.label));
+        }
+        return undefined;
+    }
+}
+class ReactionAction extends Action {
+    static { this.ID = 'toolbar.toggle.reaction'; }
+    constructor(id, label = '', cssClass = '', enabled = true, actionCallback, icon, count) {
+        super(ReactionAction.ID, label, cssClass, enabled, actionCallback);
+        this.icon = icon;
+        this.count = count;
+    }
+}
+export { ReactionAction, ReactionActionViewItem, ToggleReactionsAction };

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

@@ -0,0 +1,55 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { fromNow } from '../../../../base/common/date.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
+class TimestampWidget extends Disposable {
+    constructor(configurationService, container, timeStamp) {
+        super();
+        this.configurationService = configurationService;
+        this._date = dom.append(container, dom.$('span.timestamp'));
+        this._date.style.display = 'none';
+        this._useRelativeTime = this.useRelativeTimeSetting;
+        this.setTimestamp(timeStamp);
+    }
+    get useRelativeTimeSetting() {
+        return this.configurationService.getValue(COMMENTS_SECTION).useRelativeTime;
+    }
+    async setTimestamp(timestamp) {
+        if ((timestamp !== this._timestamp) || (this.useRelativeTimeSetting !== this._useRelativeTime)) {
+            this.updateDate(timestamp);
+        }
+        this._timestamp = timestamp;
+        this._useRelativeTime = this.useRelativeTimeSetting;
+    }
+    updateDate(timestamp) {
+        if (!timestamp) {
+            this._date.textContent = '';
+            this._date.style.display = 'none';
+        }
+        else if ((timestamp !== this._timestamp)
+            || (this.useRelativeTimeSetting !== this._useRelativeTime)) {
+            this._date.style.display = '';
+            let textContent;
+            let tooltip;
+            if (this.useRelativeTimeSetting) {
+                textContent = this.getRelative(timestamp);
+                tooltip = this.getDateString(timestamp);
+            }
+            else {
+                textContent = this.getDateString(timestamp);
+            }
+            this._date.textContent = textContent;
+            if (tooltip) {
+                this._date.title = tooltip;
+            }
+        }
+    }
+    getRelative(date) {
+        return fromNow(date, true, true);
+    }
+    getDateString(date) {
+        return date.toLocaleString(language);
+    }
+}
+export { TimestampWidget };

package/vscode/src/vs/workbench/contrib/comments/common/commentsConfiguration.js

@@ -0,0 +1,2 @@
+const COMMENTS_SECTION = 'comments';
+export { COMMENTS_SECTION };

package/vscode/src/vs/workbench/contrib/contextmenu/browser/contextmenu.contribution.js

@@ -0,0 +1,20 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+let ContextMenuContribution = class ContextMenuContribution {
+    constructor(layoutService, contextMenuService) {
+        this.disposables = ( new DisposableStore());
+        const update = (visible) => layoutService.activeContainer.classList.toggle('context-menu-visible', visible);
+        contextMenuService.onDidShowContextMenu(() => update(true), null, this.disposables);
+        contextMenuService.onDidHideContextMenu(() => update(false), null, this.disposables);
+    }
+};
+ContextMenuContribution = ( __decorate([
+    ( __param(0, ILayoutService)),
+    ( __param(1, IContextMenuService))
+], ContextMenuContribution));
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(ContextMenuContribution, 4 );