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

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

@@ -0,0 +1,178 @@
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { CommentsViewFilterFocusContextKey } from './comments.js';
+import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { COMMENTS_VIEW_ID } from './commentsTreeViewer.js';
+import { FocusedViewContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { viewFilterSubmenu } from 'vscode/vscode/vs/workbench/browser/parts/views/viewFilter';
+
+const CONTEXT_KEY_SHOW_RESOLVED = ( new RawContextKey('commentsView.showResolvedFilter', true));
+const CONTEXT_KEY_SHOW_UNRESOLVED = ( new RawContextKey('commentsView.showUnResolvedFilter', true));
+class CommentsFilters extends Disposable {
+    constructor(options, contextKeyService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._showUnresolved = CONTEXT_KEY_SHOW_UNRESOLVED.bindTo(this.contextKeyService);
+        this._showResolved = CONTEXT_KEY_SHOW_RESOLVED.bindTo(this.contextKeyService);
+        this._showResolved.set(options.showResolved);
+        this._showUnresolved.set(options.showUnresolved);
+    }
+    get showUnresolved() {
+        return !!this._showUnresolved.get();
+    }
+    set showUnresolved(showUnresolved) {
+        if (this._showUnresolved.get() !== showUnresolved) {
+            this._showUnresolved.set(showUnresolved);
+            this._onDidChange.fire({ showUnresolved: true });
+        }
+    }
+    get showResolved() {
+        return !!this._showResolved.get();
+    }
+    set showResolved(showResolved) {
+        if (this._showResolved.get() !== showResolved) {
+            this._showResolved.set(showResolved);
+            this._onDidChange.fire({ showResolved: true });
+        }
+    }
+}
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'commentsFocusViewFromFilter',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsViewActions',
+                'focusCommentsList',
+                "Focus Comments view"
+            )),
+            keybinding: {
+                when: CommentsViewFilterFocusContextKey,
+                weight: 200 ,
+                primary: 2048  | 18
+            },
+            viewId: COMMENTS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, commentsView) {
+        commentsView.focus();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'commentsClearFilterText',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsViewActions',
+                'commentsClearFilterText',
+                "Clear filter text"
+            )),
+            keybinding: {
+                when: CommentsViewFilterFocusContextKey,
+                weight: 200 ,
+                primary: 9
+            },
+            viewId: COMMENTS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, commentsView) {
+        commentsView.clearFilterText();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'commentsFocusFilter',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsViewActions',
+                'focusCommentsFilter',
+                "Focus comments filter"
+            )),
+            keybinding: {
+                when: ( FocusedViewContext.isEqualTo(COMMENTS_VIEW_ID)),
+                weight: 200 ,
+                primary: 2048  | 36
+            },
+            viewId: COMMENTS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, commentsView) {
+        commentsView.focusFilter();
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleUnResolvedComments`,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsViewActions',
+                'toggle unresolved',
+                "Toggle Unresolved Comments"
+            )),
+            category: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsViewActions',
+                'comments',
+                "Comments"
+            )),
+            toggled: {
+                condition: CONTEXT_KEY_SHOW_UNRESOLVED,
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/comments/browser/commentsViewActions',
+                    'unresolved',
+                    "Show Unresolved"
+                )),
+            },
+            menu: {
+                id: viewFilterSubmenu,
+                group: '1_filter',
+                when: ( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)),
+                order: 1
+            },
+            viewId: COMMENTS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.showUnresolved = !view.filters.showUnresolved;
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleResolvedComments`,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsViewActions',
+                'toggle resolved',
+                "Toggle Resolved Comments"
+            )),
+            category: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsViewActions',
+                'comments',
+                "Comments"
+            )),
+            toggled: {
+                condition: CONTEXT_KEY_SHOW_RESOLVED,
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/comments/browser/commentsViewActions',
+                    'resolved',
+                    "Show Resolved"
+                )),
+            },
+            menu: {
+                id: viewFilterSubmenu,
+                group: '1_filter',
+                when: ( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)),
+                order: 1
+            },
+            viewId: COMMENTS_VIEW_ID
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.showResolved = !view.filters.showResolved;
+    }
+});
+
+export { CommentsFilters };

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

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".comments-panel .comments-panel-container{height:100%}.comments-panel .comments-panel-container .hidden{display:none}.comments-panel .comments-panel-container .tree-container{height:100%}.comments-panel .comments-panel-container .tree-container.hidden{display:none;visibility:hidden}.comments-panel .comments-panel-container .tree-container .comment-thread-container{display:block}.comments-panel .comments-panel-container .tree-container .comment-thread-container div{overflow:hidden}.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-metadata-container,.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-snippet-container,.comments-panel .comments-panel-container .tree-container .resource-container{display:flex;overflow:hidden;text-overflow:ellipsis}.comments-panel .count,.comments-panel .user{padding-right:5px}.comments-panel .comments-panel-container .tree-container .comment-thread-container .icon{min-width:fit-content;padding-right:5px;padding-top:4px}.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-metadata-container .user,.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-snippet-container .count{min-width:fit-content}.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-snippet-container .text{display:flex;flex:1;min-width:0}.comments-panel .comments-panel-container .tree-container .comment-thread-container .reply-detail,.comments-panel .comments-panel-container .tree-container .comment-thread-container .timestamp{display:block;font-size:.9em;opacity:.8;overflow:hidden;padding-right:5px;text-overflow:ellipsis}.comments-panel .comments-panel-container .tree-container .comment-thread-container .text *{margin:0;max-width:500px;overflow:hidden;padding-right:5px;text-overflow:ellipsis}.comments-panel .comments-panel-container .tree-container .comment-thread-container .range{opacity:.8}.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-snippet-container .text code{font-family:var(--monaco-monospace-font)}.comments-panel .comments-panel-container .tree-container .comment-thread-container .separator{opacity:.8;padding-right:5px}.comments-panel .comments-panel-container .message-box-container{height:inherit;line-height:22px;padding-left:20px}.comments-panel .comments-panel-container .tree-container .count-badge-wrapper{margin-left:10px}.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-metadata-container,.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-snippet-container{line-height:22px;margin-right:5px}.comments-panel .comments-panel-container .tree-container .comment-thread-container .comment-snippet-container{padding-left:16px}.comments-panel .hide{display:none}";
+n(css,{});
+
+export { css, css as default };

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

@@ -0,0 +1,6 @@
+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-peekViewTitle-background);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-peekViewTitle-background)}.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,101 @@
+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,57 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { fromNow } from 'vscode/vscode/vs/base/common/date';
+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/commentModel.js

@@ -0,0 +1,145 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { groupBy } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+class CommentNode {
+    constructor(owner, threadId, resource, comment, range, threadState) {
+        this.replies = [];
+        this.owner = owner;
+        this.threadId = threadId;
+        this.comment = comment;
+        this.resource = resource;
+        this.range = range;
+        this.isRoot = false;
+        this.threadState = threadState;
+    }
+    hasReply() {
+        return this.replies && this.replies.length !== 0;
+    }
+}
+class ResourceWithCommentThreads {
+    constructor(owner, resource, commentThreads) {
+        this.owner = owner;
+        this.id = ( resource.toString());
+        this.resource = resource;
+        this.commentThreads = ( commentThreads.filter(thread => thread.comments && thread.comments.length).map(
+            thread => ResourceWithCommentThreads.createCommentNode(owner, resource, thread)
+        ));
+    }
+    static createCommentNode(owner, resource, commentThread) {
+        const { threadId, comments, range } = commentThread;
+        const commentNodes = ( comments.map(comment => ( new CommentNode(owner, threadId, resource, comment, range, commentThread.state))));
+        if (commentNodes.length > 1) {
+            commentNodes[0].replies = commentNodes.slice(1, commentNodes.length);
+        }
+        commentNodes[0].isRoot = true;
+        return commentNodes[0];
+    }
+}
+class CommentsModel {
+    constructor() {
+        this.resourceCommentThreads = [];
+        this.commentThreadsMap = ( new Map());
+    }
+    updateResourceCommentThreads() {
+        this.resourceCommentThreads = [...( this.commentThreadsMap.values())].flat();
+        this.resourceCommentThreads.sort((a, b) => {
+            return ( a.resource.toString()) > ( b.resource.toString()) ? 1 : -1;
+        });
+    }
+    setCommentThreads(owner, commentThreads) {
+        this.commentThreadsMap.set(owner, this.groupByResource(owner, commentThreads));
+        this.updateResourceCommentThreads();
+    }
+    deleteCommentsByOwner(owner) {
+        if (owner) {
+            this.commentThreadsMap.set(owner, []);
+        }
+        else {
+            this.commentThreadsMap.clear();
+        }
+        this.updateResourceCommentThreads();
+    }
+    updateCommentThreads(event) {
+        const { owner, removed, changed, added } = event;
+        const threadsForOwner = this.commentThreadsMap.get(owner) || [];
+        removed.forEach(thread => {
+            const matchingResourceIndex = threadsForOwner.findIndex((resourceData) => resourceData.id === thread.resource);
+            const matchingResourceData = matchingResourceIndex >= 0 ? threadsForOwner[matchingResourceIndex] : undefined;
+            const index = matchingResourceData?.commentThreads.findIndex((commentThread) => commentThread.threadId === thread.threadId) ?? 0;
+            if (index >= 0) {
+                matchingResourceData?.commentThreads.splice(index, 1);
+            }
+            if (matchingResourceData?.commentThreads.length === 0) {
+                threadsForOwner.splice(matchingResourceIndex, 1);
+            }
+        });
+        changed.forEach(thread => {
+            const matchingResourceIndex = threadsForOwner.findIndex((resourceData) => resourceData.id === thread.resource);
+            const matchingResourceData = threadsForOwner[matchingResourceIndex];
+            const index = matchingResourceData.commentThreads.findIndex((commentThread) => commentThread.threadId === thread.threadId);
+            if (index >= 0) {
+                matchingResourceData.commentThreads[index] = ResourceWithCommentThreads.createCommentNode(owner, ( URI.parse(matchingResourceData.id)), thread);
+            }
+            else if (thread.comments && thread.comments.length) {
+                matchingResourceData.commentThreads.push(ResourceWithCommentThreads.createCommentNode(owner, ( URI.parse(matchingResourceData.id)), thread));
+            }
+        });
+        added.forEach(thread => {
+            const existingResource = threadsForOwner.filter(resourceWithThreads => ( resourceWithThreads.resource.toString()) === thread.resource);
+            if (existingResource.length) {
+                const resource = existingResource[0];
+                if (thread.comments && thread.comments.length) {
+                    resource.commentThreads.push(ResourceWithCommentThreads.createCommentNode(owner, resource.resource, thread));
+                }
+            }
+            else {
+                threadsForOwner.push(( new ResourceWithCommentThreads(owner, ( URI.parse(thread.resource)), [thread])));
+            }
+        });
+        this.commentThreadsMap.set(owner, threadsForOwner);
+        this.updateResourceCommentThreads();
+        return removed.length > 0 || changed.length > 0 || added.length > 0;
+    }
+    hasCommentThreads() {
+        return !!this.resourceCommentThreads.length;
+    }
+    getMessage() {
+        if (!this.resourceCommentThreads.length) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/comments/common/commentModel',
+                'noComments',
+                "There are no comments in this workspace yet."
+            ));
+        }
+        else {
+            return '';
+        }
+    }
+    groupByResource(owner, commentThreads) {
+        const resourceCommentThreads = [];
+        const commentThreadsByResource = ( new Map());
+        for (const group of groupBy(commentThreads, CommentsModel._compareURIs)) {
+            commentThreadsByResource.set(group[0].resource, ( new ResourceWithCommentThreads(owner, ( URI.parse(group[0].resource)), group)));
+        }
+        commentThreadsByResource.forEach((v, i, m) => {
+            resourceCommentThreads.push(v);
+        });
+        return resourceCommentThreads;
+    }
+    static _compareURIs(a, b) {
+        const resourceA = ( a.resource.toString());
+        const resourceB = ( b.resource.toString());
+        if (resourceA < resourceB) {
+            return -1;
+        }
+        else if (resourceA > resourceB) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+
+export { CommentNode, CommentsModel, ResourceWithCommentThreads };

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

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

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -0,0 +1,73 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+
+var CustomTextEditorModel_1;
+let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorModel extends Disposable {
+    static async create(instantiationService, viewType, resource) {
+        return instantiationService.invokeFunction(async (accessor) => {
+            const textModelResolverService = accessor.get(ITextModelService);
+            const model = await textModelResolverService.createModelReference(resource);
+            return instantiationService.createInstance(CustomTextEditorModel_1, viewType, resource, model);
+        });
+    }
+    constructor(viewType, _resource, _model, textFileService) {
+        super();
+        this.viewType = viewType;
+        this._resource = _resource;
+        this._model = _model;
+        this.textFileService = textFileService;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._register(_model);
+        this._textFileModel = this.textFileService.files.get(_resource);
+        if (this._textFileModel) {
+            this._register(this._textFileModel.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire()));
+            this._register(this._textFileModel.onDidChangeReadonly(() => this._onDidChangeReadonly.fire()));
+        }
+        this._register(this.textFileService.files.onDidChangeDirty(e => {
+            if (isEqual(this.resource, e.resource)) {
+                this._onDidChangeDirty.fire();
+                this._onDidChangeContent.fire();
+            }
+        }));
+    }
+    get resource() {
+        return this._resource;
+    }
+    isReadonly() {
+        return this._model.object.isReadonly();
+    }
+    get backupId() {
+        return undefined;
+    }
+    isDirty() {
+        return this.textFileService.isDirty(this.resource);
+    }
+    isOrphaned() {
+        return !!this._textFileModel?.hasState(4 );
+    }
+    async revert(options) {
+        return this.textFileService.revert(this.resource, options);
+    }
+    saveCustomEditor(options) {
+        return this.textFileService.save(this.resource, options);
+    }
+    async saveCustomEditorAs(resource, targetResource, options) {
+        return !!(await this.textFileService.saveAs(resource, targetResource, options));
+    }
+};
+CustomTextEditorModel = CustomTextEditorModel_1 = ( __decorate([
+    ( __param(3, ITextFileService))
+], CustomTextEditorModel));
+
+export { CustomTextEditorModel };