@codingame/monaco-vscode-comments-service-override 25.1.2 → 26.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-comments-service-override",
-  "version": "25.1.2",
+  "version": "26.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - comments service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.2"
+    "@codingame/monaco-vscode-api": "26.0.1"
   },
   "main": "index.js",
   "module": "index.js",

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

@@ -17,7 +17,9 @@ let CommentMenus = class CommentMenus {
         return this.getMenu(MenuId.CommentEditorActions, contextKeyService);
     }
     getCommentThreadAdditionalActions(contextKeyService) {
-        return this.getMenu(MenuId.CommentThreadAdditionalActions, contextKeyService, { emitEventsForSubmenuChanges: true });
+        return this.getMenu(MenuId.CommentThreadAdditionalActions, contextKeyService, {
+            emitEventsForSubmenuChanges: true
+        });
     }
     getCommentTitleActions(comment, contextKeyService) {
         return this.getMenu(MenuId.CommentTitle, contextKeyService);
@@ -26,19 +28,18 @@ let CommentMenus = class CommentMenus {
         return this.getMenu(MenuId.CommentActions, contextKeyService);
     }
     getCommentThreadTitleContextActions(contextKeyService) {
-        return this.getActions(MenuId.CommentThreadTitleContext, contextKeyService, { shouldForwardArgs: true });
+        return this.getActions(MenuId.CommentThreadTitleContext, contextKeyService, {
+            shouldForwardArgs: true
+        });
     }
     getMenu(menuId, contextKeyService, options) {
         return this.menuService.createMenu(menuId, contextKeyService, options);
     }
     getActions(menuId, contextKeyService, options) {
-        return ( this.menuService.getMenuActions(menuId, contextKeyService, options).map((value) => value[1])).flat();
-    }
-    dispose() {
+        return ( this.menuService.getMenuActions(menuId, contextKeyService, options).map(value => value[1])).flat();
     }
+    dispose() {}
 };
-CommentMenus = ( __decorate([
-    ( __param(0, IMenuService))
-], CommentMenus));
+CommentMenus = ( __decorate([( __param(0, IMenuService))], CommentMenus));
 
 export { CommentMenus };

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

@@ -18,9 +18,17 @@ import { CommentsModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 
-const CONTINUE_ON_COMMENTS = 'comments.continueOnComments';
+const CONTINUE_ON_COMMENTS = "comments.continueOnComments";
 let CommentService = class CommentService extends Disposable {
-    constructor(instantiationService, layoutService, configurationService, contextKeyService, storageService, logService, modelService) {
+    constructor(
+        instantiationService,
+        layoutService,
+        configurationService,
+        contextKeyService,
+        storageService,
+        logService,
+        modelService
+    ) {
         super();
         this.instantiationService = instantiationService;
         this.layoutService = layoutService;
@@ -66,7 +74,11 @@ let CommentService = class CommentService extends Disposable {
         this._workspaceHasCommenting = CommentContextKeys.WorkspaceHasCommenting.bindTo(contextKeyService);
         this._commentingEnabled = CommentContextKeys.commentingEnabled.bindTo(contextKeyService);
         const storageListener = this._register(( new DisposableStore()));
-        const storageEvent = Event.debounce(this.storageService.onDidChangeValue(StorageScope.WORKSPACE, CONTINUE_ON_COMMENTS, storageListener), (last, event) => last?.external ? last : event, 500);
+        const storageEvent = Event.debounce(
+            this.storageService.onDidChangeValue(StorageScope.WORKSPACE, CONTINUE_ON_COMMENTS, storageListener),
+            (last, event) => last?.external ? last : event,
+            500
+        );
         storageListener.add(storageEvent(v => {
             if (!v.external) {
                 return;
@@ -75,7 +87,7 @@ let CommentService = class CommentService extends Disposable {
             if (!commentsToRestore) {
                 return;
             }
-            this.logService.debug(`Comments: URIs of continue on comments from storage ${( commentsToRestore.map(thread => ( thread.uri.toString()))).join(', ')}.`);
+            this.logService.debug(`Comments: URIs of continue on comments from storage ${( commentsToRestore.map(thread => ( thread.uri.toString()))).join(", ")}.`);
             const changedOwners = this._addContinueOnComments(commentsToRestore, this._continueOnComments);
             for (const uniqueOwner of changedOwners) {
                 const control = this._commentControls.get(uniqueOwner);
@@ -126,7 +138,7 @@ let CommentService = class CommentService extends Disposable {
     _handleConfiguration() {
         this._isCommentingEnabled = this._defaultCommentingEnablement;
         this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('comments.visible')) {
+            if (e.affectsConfiguration("comments.visible")) {
                 this.enableCommenting(this._defaultCommentingEnablement);
             }
         }));
@@ -137,8 +149,7 @@ let CommentService = class CommentService extends Disposable {
             if (e) {
                 preZenModeValue = this._isCommentingEnabled;
                 this.enableCommenting(false);
-            }
-            else {
+            } else {
                 this.enableCommenting(preZenModeValue);
             }
         }));
@@ -177,11 +188,18 @@ let CommentService = class CommentService extends Disposable {
         return commentController.setActiveCommentAndThread(commentInfo);
     }
     setDocumentComments(resource, commentInfos) {
-        this._onDidSetResourceCommentInfos.fire({ resource, commentInfos });
+        this._onDidSetResourceCommentInfos.fire({
+            resource,
+            commentInfos
+        });
     }
     setModelThreads(ownerId, owner, ownerLabel, commentThreads) {
         this._commentsModel.setCommentThreads(ownerId, owner, ownerLabel, commentThreads);
-        this._onDidSetAllCommentThreads.fire({ ownerId, ownerLabel, commentThreads });
+        this._onDidSetAllCommentThreads.fire({
+            ownerId,
+            ownerLabel,
+            commentThreads
+        });
     }
     updateModelThreads(event) {
         this._commentsModel.updateCommentThreads(event);
@@ -209,8 +227,7 @@ let CommentService = class CommentService extends Disposable {
     unregisterCommentController(uniqueOwner) {
         if (uniqueOwner) {
             this._commentControls.delete(uniqueOwner);
-        }
-        else {
+        } else {
             this._commentControls.clear();
         }
         this._commentsModel.deleteCommentsByOwner(uniqueOwner);
@@ -248,12 +265,18 @@ let CommentService = class CommentService extends Disposable {
     updateComments(ownerId, event) {
         const control = this._commentControls.get(ownerId);
         if (control) {
-            const evt = Object.assign({}, event, { uniqueOwner: ownerId, ownerLabel: control.label, owner: control.owner });
+            const evt = Object.assign({}, event, {
+                uniqueOwner: ownerId,
+                ownerLabel: control.label,
+                owner: control.owner
+            });
             this.updateModelThreads(evt);
         }
     }
     updateNotebookComments(ownerId, event) {
-        const evt = Object.assign({}, event, { uniqueOwner: ownerId });
+        const evt = Object.assign({}, event, {
+            uniqueOwner: ownerId
+        });
         this._onDidUpdateNotebookCommentThreads.fire(evt);
     }
     updateCommentingRanges(ownerId, resourceHints) {
@@ -263,15 +286,16 @@ let CommentService = class CommentService extends Disposable {
             }
         }
         this._workspaceHasCommenting.set(true);
-        this._onDidUpdateCommentingRanges.fire({ uniqueOwner: ownerId });
+        this._onDidUpdateCommentingRanges.fire({
+            uniqueOwner: ownerId
+        });
     }
     async toggleReaction(uniqueOwner, resource, thread, comment, reaction) {
         const commentController = this._commentControls.get(uniqueOwner);
         if (commentController) {
             return commentController.toggleReaction(resource, thread, comment, reaction, CancellationToken.None);
-        }
-        else {
-            throw ( new Error('Not supported'));
+        } else {
+            throw ( new Error("Not supported"));
         }
     }
     hasReactionHandler(uniqueOwner) {
@@ -284,20 +308,24 @@ let CommentService = class CommentService extends Disposable {
     async getDocumentComments(resource) {
         const commentControlResult = [];
         for (const control of ( this._commentControls.values())) {
-            commentControlResult.push(control.getDocumentComments(resource, CancellationToken.None)
-                .then(documentComments => {
-                for (const documentCommentThread of documentComments.threads) {
-                    if (documentCommentThread.comments?.length === 0 && documentCommentThread.range) {
-                        this.removeContinueOnComment({ range: documentCommentThread.range, uri: resource, uniqueOwner: documentComments.uniqueOwner });
+            commentControlResult.push(
+                control.getDocumentComments(resource, CancellationToken.None).then(documentComments => {
+                    for (const documentCommentThread of documentComments.threads) {
+                        if (documentCommentThread.comments?.length === 0 && documentCommentThread.range) {
+                            this.removeContinueOnComment({
+                                range: documentCommentThread.range,
+                                uri: resource,
+                                uniqueOwner: documentComments.uniqueOwner
+                            });
+                        }
                     }
-                }
-                const pendingComments = this._continueOnComments.get(documentComments.uniqueOwner);
-                documentComments.pendingCommentThreads = pendingComments?.filter(pendingComment => ( pendingComment.uri.toString()) === ( resource.toString()));
-                return documentComments;
-            })
-                .catch(_ => {
-                return null;
-            }));
+                    const pendingComments = this._continueOnComments.get(documentComments.uniqueOwner);
+                    documentComments.pendingCommentThreads = pendingComments?.filter(pendingComment => ( pendingComment.uri.toString()) === ( resource.toString()));
+                    return documentComments;
+                }).catch(_ => {
+                    return null;
+                })
+            );
         }
         const commentInfos = await Promise.all(commentControlResult);
         this._updateResourcesWithCommentingRanges(resource, commentInfos);
@@ -306,8 +334,7 @@ let CommentService = class CommentService extends Disposable {
     async getNotebookComments(resource) {
         const commentControlResult = [];
         this._commentControls.forEach(control => {
-            commentControlResult.push(control.getNotebookComments(resource, CancellationToken.None)
-                .catch(_ => {
+            commentControlResult.push(control.getNotebookComments(resource, CancellationToken.None).catch(_ => {
                 return null;
             }));
         });
@@ -326,8 +353,13 @@ let CommentService = class CommentService extends Disposable {
         for (const pendingComments of ( map.values())) {
             commentsToSave.push(...pendingComments);
         }
-        this.logService.debug(`Comments: URIs of continue on comments to add to storage ${( commentsToSave.map(thread => ( thread.uri.toString()))).join(', ')}.`);
-        this.storageService.store(CONTINUE_ON_COMMENTS, commentsToSave, StorageScope.WORKSPACE, StorageTarget.USER);
+        this.logService.debug(`Comments: URIs of continue on comments to add to storage ${( commentsToSave.map(thread => ( thread.uri.toString()))).join(", ")}.`);
+        this.storageService.store(
+            CONTINUE_ON_COMMENTS,
+            commentsToSave,
+            StorageScope.WORKSPACE,
+            StorageTarget.USER
+        );
     }
     removeContinueOnComment(pendingComment) {
         const pendingComments = this._continueOnComments.get(pendingComment.uniqueOwner);
@@ -345,8 +377,7 @@ let CommentService = class CommentService extends Disposable {
             if (!( map.has(pendingComment.uniqueOwner))) {
                 map.set(pendingComment.uniqueOwner, [pendingComment]);
                 changedOwners.add(pendingComment.uniqueOwner);
-            }
-            else {
+            } else {
                 const commentsForOwner = map.get(pendingComment.uniqueOwner);
                 if (commentsForOwner.every(comment => (( comment.uri.toString()) !== ( pendingComment.uri.toString())) || !Range.equalsRange(comment.range, pendingComment.range))) {
                     commentsForOwner.push(pendingComment);
@@ -360,14 +391,6 @@ let CommentService = class CommentService extends Disposable {
         return ( this._commentingRangeResourceHintSchemes.has(resource.scheme)) || ( this._commentingRangeResources.has(( resource.toString())));
     }
 };
-CommentService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkbenchLayoutService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IModelService))
-], CommentService));
+CommentService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IWorkbenchLayoutService)), ( __param(2, IConfigurationService)), ( __param(3, IContextKeyService)), ( __param(4, IStorageService)), ( __param(5, ILogService)), ( __param(6, IModelService))], CommentService));
 
 export { CommentService };

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

@@ -32,14 +32,14 @@ registerAction2(class Collapse extends ViewAction {
     constructor() {
         super({
             viewId: COMMENTS_VIEW_ID,
-            id: 'comments.collapse',
-            title: ( localize(6319, "Collapse All")),
+            id: "comments.collapse",
+            title: ( localize(6628, "Collapse All")),
             f1: false,
             icon: Codicon.collapseAll,
             menu: {
                 id: MenuId.ViewTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.and(( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)), CONTEXT_KEY_HAS_COMMENTS)), CONTEXT_KEY_SOME_COMMENTS_EXPANDED)),
+                group: "navigation",
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.and(( ContextKeyExpr.equals("view", COMMENTS_VIEW_ID)), CONTEXT_KEY_HAS_COMMENTS)), CONTEXT_KEY_SOME_COMMENTS_EXPANDED)),
                 order: 100
             }
         });
@@ -52,14 +52,14 @@ registerAction2(class Expand extends ViewAction {
     constructor() {
         super({
             viewId: COMMENTS_VIEW_ID,
-            id: 'comments.expand',
-            title: ( localize(6320, "Expand All")),
+            id: "comments.expand",
+            title: ( localize(6629, "Expand All")),
             f1: false,
             icon: Codicon.expandAll,
             menu: {
                 id: MenuId.ViewTitle,
-                group: 'navigation',
-                when: ( ContextKeyExpr.and(( ContextKeyExpr.and(( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)), CONTEXT_KEY_HAS_COMMENTS)), ContextKeyExpr.not(CONTEXT_KEY_SOME_COMMENTS_EXPANDED.key))),
+                group: "navigation",
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.and(( ContextKeyExpr.equals("view", COMMENTS_VIEW_ID)), CONTEXT_KEY_HAS_COMMENTS)), ContextKeyExpr.not(CONTEXT_KEY_SOME_COMMENTS_EXPANDED.key))),
                 order: 100
             }
         });
@@ -71,92 +71,98 @@ registerAction2(class Expand extends ViewAction {
 registerAction2(class Reply extends Action2 {
     constructor() {
         super({
-            id: 'comments.reply',
-            title: ( localize(6321, "Reply")),
+            id: "comments.reply",
+            title: ( localize(6630, "Reply")),
             icon: Codicon.reply,
-            precondition: ( ContextKeyExpr.equals('canReply', true)),
+            precondition: ( ContextKeyExpr.equals("canReply", true)),
             menu: [{
-                    id: MenuId.CommentsViewThreadActions,
-                    order: 100
-                },
-                {
-                    id: MenuId.AccessibleView,
-                    when: ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(accessibleViewCurrentProviderId.key, AccessibleViewProviderId.Comments)))),
-                }]
+                id: MenuId.CommentsViewThreadActions,
+                order: 100
+            }, {
+                id: MenuId.AccessibleView,
+                when: ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(accessibleViewCurrentProviderId.key, AccessibleViewProviderId.Comments))))
+            }]
         });
     }
     run(accessor, marshalledCommentThread) {
         const commentService = accessor.get(ICommentService);
         const editorService = accessor.get(IEditorService);
         const uriIdentityService = accessor.get(IUriIdentityService);
-        revealCommentThread(commentService, editorService, uriIdentityService, marshalledCommentThread.thread, marshalledCommentThread.thread.comments[marshalledCommentThread.thread.comments.length - 1], true);
+        revealCommentThread(
+            commentService,
+            editorService,
+            uriIdentityService,
+            marshalledCommentThread.thread,
+            marshalledCommentThread.thread.comments[marshalledCommentThread.thread.comments.length - 1],
+            true
+        );
     }
 });
 ( Registry.as(Extensions.Configuration)).registerConfiguration({
-    id: 'comments',
+    id: "comments",
     order: 20,
-    title: ( localize(6322, "Comments")),
-    type: 'object',
+    title: ( localize(6631, "Comments")),
+    type: "object",
     properties: {
-        'comments.openPanel': {
-            enum: ['neverOpen', 'openOnSessionStart', 'openOnSessionStartWithComments'],
-            default: 'openOnSessionStartWithComments',
-            description: ( localize(6323, "Controls when the comments panel should open.")),
+        "comments.openPanel": {
+            enum: ["neverOpen", "openOnSessionStart", "openOnSessionStartWithComments"],
+            default: "openOnSessionStartWithComments",
+            description: ( localize(6632, "Controls when the comments panel should open.")),
             restricted: false,
-            markdownDeprecationMessage: ( localize(6324, "This setting is deprecated in favor of `comments.openView`."))
+            markdownDeprecationMessage: ( localize(6633, "This setting is deprecated in favor of `comments.openView`."))
         },
-        'comments.openView': {
-            enum: ['never', 'file', 'firstFile', 'firstFileUnresolved'],
-            enumDescriptions: [( localize(6325, "The comments view will never be opened.")), ( localize(6326, "The comments view will open when a file with comments is active.")), ( localize(
-                6327,
+        "comments.openView": {
+            enum: ["never", "file", "firstFile", "firstFileUnresolved"],
+            enumDescriptions: [( localize(6634, "The comments view will never be opened.")), ( localize(6635, "The comments view will open when a file with comments is active.")), ( localize(
+                6636,
                 "If the comments view has not been opened yet during this session it will open the first time during a session that a file with comments is active."
             )), ( localize(
-                6328,
+                6637,
                 "If the comments view has not been opened yet during this session and the comment is not resolved, it will open the first time during a session that a file with comments is active."
             ))],
-            default: 'firstFile',
-            description: ( localize(6329, "Controls when the comments view should open.")),
+            default: "firstFile",
+            description: ( localize(6638, "Controls when the comments view should open.")),
             restricted: false
         },
-        'comments.useRelativeTime': {
-            type: 'boolean',
+        "comments.useRelativeTime": {
+            type: "boolean",
             default: true,
             description: ( localize(
-                6330,
+                6639,
                 "Determines if relative time will be used in comment timestamps (ex. '1 day ago')."
             ))
         },
-        'comments.visible': {
-            type: 'boolean',
+        "comments.visible": {
+            type: "boolean",
             default: true,
             description: ( localize(
-                6331,
+                6640,
                 "Controls the visibility of the comments bar and comment threads in editors that have commenting ranges and comments. Comments are still accessible via the Comments view and will cause commenting to be toggled on in the same way running the command \"Comments: Toggle Editor Commenting\" toggles comments."
             ))
         },
-        'comments.maxHeight': {
-            type: 'boolean',
+        "comments.maxHeight": {
+            type: "boolean",
             default: true,
-            description: ( localize(6332, "Controls whether the comments widget scrolls or expands."))
+            description: ( localize(6641, "Controls whether the comments widget scrolls or expands."))
         },
-        'comments.collapseOnResolve': {
-            type: 'boolean',
+        "comments.collapseOnResolve": {
+            type: "boolean",
             default: true,
             description: ( localize(
-                6333,
+                6642,
                 "Controls whether the comment thread should collapse when the thread is resolved."
             ))
         },
-        'comments.thread.confirmOnCollapse': {
-            type: 'string',
-            enum: ['whenHasUnsubmittedComments', 'never'],
+        "comments.thread.confirmOnCollapse": {
+            type: "string",
+            enum: ["whenHasUnsubmittedComments", "never"],
             enumDescriptions: [( localize(
-                6334,
+                6643,
                 "Show a confirmation dialog when collapsing a comment thread with unsubmitted comments."
-            )), ( localize(6335, "Never show a confirmation dialog when collapsing a comment thread."))],
-            default: 'whenHasUnsubmittedComments',
+            )), ( localize(6644, "Never show a confirmation dialog when collapsing a comment thread."))],
+            default: "whenHasUnsubmittedComments",
             description: ( localize(
-                6336,
+                6645,
                 "Controls whether a confirmation dialog is shown when collapsing a comment thread."
             ))
         }
@@ -169,8 +175,12 @@ let UnresolvedCommentsBadge = class UnresolvedCommentsBadge extends Disposable {
         this.activityService = activityService;
         this.activity = this._register(( new MutableDisposable()));
         this.totalUnresolved = 0;
-        this._register(this._commentService.onDidSetAllCommentThreads(this.onAllCommentsChanged, this));
-        this._register(this._commentService.onDidUpdateCommentThreads(this.onCommentsUpdated, this));
+        this._register(
+            this._commentService.onDidSetAllCommentThreads(this.onAllCommentsChanged, this)
+        );
+        this._register(
+            this._commentService.onDidUpdateCommentThreads(this.onCommentsUpdated, this)
+        );
         this._register(this._commentService.onDidDeleteDataProvider(this.onCommentsUpdated, this));
     }
     onAllCommentsChanged(e) {
@@ -198,14 +208,13 @@ let UnresolvedCommentsBadge = class UnresolvedCommentsBadge extends Disposable {
             return;
         }
         this.totalUnresolved = unresolved;
-        const message = ( localize(6337, '{0} Unresolved Comments', this.totalUnresolved));
-        this.activity.value = this.activityService.showViewActivity(COMMENTS_VIEW_ID, { badge: ( new NumberBadge(this.totalUnresolved, () => message)) });
+        const message = ( localize(6646, "{0} Unresolved Comments", this.totalUnresolved));
+        this.activity.value = this.activityService.showViewActivity(COMMENTS_VIEW_ID, {
+            badge: ( new NumberBadge(this.totalUnresolved, () => message))
+        });
     }
 };
-UnresolvedCommentsBadge = ( __decorate([
-    ( __param(0, ICommentService)),
-    ( __param(1, IActivityService))
-], UnresolvedCommentsBadge));
+UnresolvedCommentsBadge = ( __decorate([( __param(0, ICommentService)), ( __param(1, IActivityService))], UnresolvedCommentsBadge));
 ( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(UnresolvedCommentsBadge, LifecyclePhase.Eventually);
 AccessibleViewRegistry.register(( new CommentsAccessibleView()));
 AccessibleViewRegistry.register(( new CommentThreadAccessibleView()));

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

@@ -34,7 +34,7 @@ class CommentsAccessibleView extends Disposable {
     constructor() {
         super();
         this.priority = 90;
-        this.name = 'comment';
+        this.name = "comment";
         this.when = CONTEXT_KEY_COMMENT_FOCUSED;
         this.type = AccessibleViewType.View;
     }
@@ -53,7 +53,7 @@ class CommentThreadAccessibleView extends Disposable {
     constructor() {
         super();
         this.priority = 85;
-        this.name = 'commentThread';
+        this.name = "commentThread";
         this.when = CommentContextKeys.commentFocused;
         this.type = AccessibleViewType.View;
     }
@@ -66,7 +66,9 @@ class CommentsAccessibleContentProvider extends Disposable {
         this._menus = _menus;
         this.id = AccessibleViewProviderId.Comments;
         this.verbositySettingKey = AccessibilityVerbositySettingId.Comments;
-        this.options = { type: AccessibleViewType.View };
+        this.options = {
+            type: AccessibleViewType.View
+        };
         this.actions = ( [...this._menus.getResourceContextActions(this._focusedCommentNode)].filter(i => i.enabled).map(action => {
             return {
                 ...action,
@@ -76,7 +78,7 @@ class CommentsAccessibleContentProvider extends Disposable {
                         thread: this._focusedCommentNode.thread,
                         $mid: MarshalledId.CommentThread,
                         commentControlHandle: this._focusedCommentNode.controllerHandle,
-                        commentThreadHandle: this._focusedCommentNode.threadHandle,
+                        commentThreadHandle: this._focusedCommentNode.threadHandle
                     });
                 }
             };
@@ -86,7 +88,7 @@ class CommentsAccessibleContentProvider extends Disposable {
         const commentNode = this._commentsView.focusedCommentNode;
         const content = this._commentsView.focusedCommentInfo?.toString();
         if (!commentNode || !content) {
-            throw ( new Error('Comment tree is focused but no comment is selected'));
+            throw ( new Error("Comment tree is focused but no comment is selected"));
         }
         return content;
     }
@@ -110,7 +112,9 @@ let CommentsThreadWidgetAccessibleContentProvider = class CommentsThreadWidgetAc
         this._uriIdentityService = _uriIdentityService;
         this.id = AccessibleViewProviderId.CommentThread;
         this.verbositySettingKey = AccessibilityVerbositySettingId.Comments;
-        this.options = { type: AccessibleViewType.View };
+        this.options = {
+            type: AccessibleViewType.View
+        };
     }
     get activeCommentInfo() {
         if (!this._activeCommentInfo && this._commentService.lastActiveCommentcontroller) {
@@ -120,20 +124,20 @@ let CommentsThreadWidgetAccessibleContentProvider = class CommentsThreadWidgetAc
     }
     provideContent() {
         if (!this.activeCommentInfo) {
-            throw ( new Error('No current comment thread'));
+            throw ( new Error("No current comment thread"));
         }
         const comment = this.activeCommentInfo.comment?.body;
-        const commentLabel = typeof comment === 'string' ? comment : comment?.value ?? '';
+        const commentLabel = typeof comment === "string" ? comment : comment?.value ?? "";
         const resource = this.activeCommentInfo.thread.resource;
         const range = this.activeCommentInfo.thread.range;
-        let contentLabel = '';
+        let contentLabel = "";
         if (resource && range) {
             const editor = this._editorService.findEditors(( URI.parse(resource))) || [];
             const codeEditor = this._editorService.activeEditorPane?.getControl();
             if (editor?.length && isCodeEditor(codeEditor)) {
                 const content = codeEditor.getModel()?.getValueInRange(range);
                 if (content) {
-                    contentLabel = '\nCorresponding code: \n' + content;
+                    contentLabel = "\nCorresponding code: \n" + content;
                 }
             }
         }
@@ -143,11 +147,17 @@ let CommentsThreadWidgetAccessibleContentProvider = class CommentsThreadWidgetAc
         const lastComment = this._activeCommentInfo;
         this._activeCommentInfo = undefined;
         if (lastComment) {
-            revealCommentThread(this._commentService, this._editorService, this._uriIdentityService, lastComment.thread, lastComment.comment);
+            revealCommentThread(
+                this._commentService,
+                this._editorService,
+                this._uriIdentityService,
+                lastComment.thread,
+                lastComment.comment
+            );
         }
     }
     provideNextContent() {
-        const newCommentInfo = moveToNextCommentInThread(this._activeCommentInfo, 'next');
+        const newCommentInfo = moveToNextCommentInThread(this._activeCommentInfo, "next");
         if (newCommentInfo) {
             this._activeCommentInfo = newCommentInfo;
             return this.provideContent();
@@ -155,7 +165,7 @@ let CommentsThreadWidgetAccessibleContentProvider = class CommentsThreadWidgetAc
         return undefined;
     }
     providePreviousContent() {
-        const newCommentInfo = moveToNextCommentInThread(this._activeCommentInfo, 'previous');
+        const newCommentInfo = moveToNextCommentInThread(this._activeCommentInfo, "previous");
         if (newCommentInfo) {
             this._activeCommentInfo = newCommentInfo;
             return this.provideContent();
@@ -163,10 +173,6 @@ let CommentsThreadWidgetAccessibleContentProvider = class CommentsThreadWidgetAc
         return undefined;
     }
 };
-CommentsThreadWidgetAccessibleContentProvider = ( __decorate([
-    ( __param(0, ICommentService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, IUriIdentityService))
-], CommentsThreadWidgetAccessibleContentProvider));
+CommentsThreadWidgetAccessibleContentProvider = ( __decorate([( __param(0, ICommentService)), ( __param(1, IEditorService)), ( __param(2, IUriIdentityService))], CommentsThreadWidgetAccessibleContentProvider));
 
 export { CommentThreadAccessibleView, CommentsAccessibleView };

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

@@ -29,7 +29,11 @@ import { CommentThreadCollapsibleState, CommentThreadState } from '@codingame/mo
 
 registerCss(review);
 registerEditorContribution(ID, CommentController, EditorContributionInstantiation.AfterFirstRender);
-registerWorkbenchContribution2(CommentsInputContentProvider.ID, CommentsInputContentProvider, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2(
+    CommentsInputContentProvider.ID,
+    CommentsInputContentProvider,
+    WorkbenchPhase.BlockRestore
+);
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: CommentCommandId.NextThread,
     handler: async (accessor, args) => {
@@ -44,7 +48,7 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         controller.nextCommentThread(true);
     },
     weight: KeybindingWeight.EditorContrib,
-    primary: KeyMod.Alt | KeyCode.F9,
+    primary: KeyMod.Alt | KeyCode.F9
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: CommentCommandId.PreviousThread,
@@ -67,17 +71,17 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.NextCommentedRange,
             title: {
-                value: ( localize(6358, "Go to Next Commented Range")),
-                original: 'Go to Next Commented Range'
+                value: ( localize(6667, "Go to Next Commented Range")),
+                original: "Go to Next Commented Range"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.activeEditorHasCommentingRange
-                }],
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.activeEditorHasCommentingRange
+            }],
             keybinding: {
                 primary: KeyMod.Alt | KeyCode.F10,
                 weight: KeybindingWeight.EditorContrib,
@@ -102,17 +106,17 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.PreviousCommentedRange,
             title: {
-                value: ( localize(6360, "Go to Previous Commented Range")),
-                original: 'Go to Previous Commented Range'
+                value: ( localize(6669, "Go to Previous Commented Range")),
+                original: "Go to Previous Commented Range"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.activeEditorHasCommentingRange
-                }],
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.activeEditorHasCommentingRange
+            }],
             keybinding: {
                 primary: KeyMod.Shift | KeyMod.Alt | KeyCode.F10,
                 weight: KeybindingWeight.EditorContrib,
@@ -137,19 +141,22 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.NextRange,
             title: {
-                value: ( localize(6361, "Go to Next Commenting Range")),
-                original: 'Go to Next Commenting Range'
+                value: ( localize(6670, "Go to Next Commenting Range")),
+                original: "Go to Next Commenting Range"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.activeEditorHasCommentingRange
-                }],
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.activeEditorHasCommentingRange
+            }],
             keybinding: {
-                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.DownArrow),
+                primary: KeyChord(
+                    KeyMod.CtrlCmd | KeyCode.KeyK,
+                    KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.DownArrow
+                ),
                 weight: KeybindingWeight.EditorContrib,
                 when: ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, ( ContextKeyExpr.or(EditorContextKeys.focus, CommentContextKeys.commentFocused, ( ContextKeyExpr.and(accessibilityHelpIsShown, ( accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Comments))))))))
             }
@@ -172,19 +179,22 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.PreviousRange,
             title: {
-                value: ( localize(6362, "Go to Previous Commenting Range")),
-                original: 'Go to Previous Commenting Range'
+                value: ( localize(6671, "Go to Previous Commenting Range")),
+                original: "Go to Previous Commenting Range"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.activeEditorHasCommentingRange
-                }],
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.activeEditorHasCommentingRange
+            }],
             keybinding: {
-                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.UpArrow),
+                primary: KeyChord(
+                    KeyMod.CtrlCmd | KeyCode.KeyK,
+                    KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.UpArrow
+                ),
                 weight: KeybindingWeight.EditorContrib,
                 when: ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, ( ContextKeyExpr.or(EditorContextKeys.focus, CommentContextKeys.commentFocused, ( ContextKeyExpr.and(accessibilityHelpIsShown, ( accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Comments))))))))
             }
@@ -207,17 +217,17 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.ToggleCommenting,
             title: {
-                value: ( localize(6363, "Toggle Editor Commenting")),
-                original: 'Toggle Editor Commenting'
+                value: ( localize(6672, "Toggle Editor Commenting")),
+                original: "Toggle Editor Commenting"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.WorkspaceHasCommenting
-                }]
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.WorkspaceHasCommenting
+            }]
         });
     }
     run(accessor, ...args) {
@@ -231,17 +241,17 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.Add,
             title: {
-                value: ( localize(6364, "Add Comment on Current Selection")),
-                original: 'Add Comment on Current Selection'
+                value: ( localize(6673, "Add Comment on Current Selection")),
+                original: "Add Comment on Current Selection"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.activeCursorHasCommentingRange
-                }],
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.activeCursorHasCommentingRange
+            }],
             keybinding: {
                 primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyC),
                 weight: KeybindingWeight.EditorContrib,
@@ -263,8 +273,7 @@ registerAction2(class extends Action2 {
             args.range.startLineNumber,
             args.range.endLineNumber,
             args.range.endColumn
-        ))
-            : (args?.fileComment ? undefined : activeEditor.getSelection());
+        )) : (args?.fileComment ? undefined : activeEditor.getSelection());
         await controller.addOrToggleCommentAtLine(position, undefined);
     }
 });
@@ -273,15 +282,15 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.FocusCommentOnCurrentLine,
             title: {
-                value: ( localize(6365, "Focus Comment on Current Line")),
-                original: 'Focus Comment on Current Line'
+                value: ( localize(6674, "Focus Comment on Current Line")),
+                original: "Focus Comment on Current Line"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             f1: true,
-            precondition: CommentContextKeys.activeCursorHasComment,
+            precondition: CommentContextKeys.activeCursorHasComment
         });
     }
     async run(accessor, ...args) {
@@ -300,16 +309,19 @@ registerAction2(class extends Action2 {
             const commentAtLine = controller.getCommentsAtLine(position);
             if (commentAtLine.length === 0) {
                 error = true;
+            } else {
+                await controller.revealCommentThread(
+                    commentAtLine[0].commentThread.threadId,
+                    undefined,
+                    false,
+                    CommentWidgetFocus.Widget
+                );
             }
-            else {
-                await controller.revealCommentThread(commentAtLine[0].commentThread.threadId, undefined, false, CommentWidgetFocus.Widget);
-            }
-        }
-        catch (e) {
+        } catch (e) {
             error = true;
         }
         if (error) {
-            notificationService.error(( localize(6366, "The cursor must be on a line with a comment to focus the comment")));
+            notificationService.error(( localize(6675, "The cursor must be on a line with a comment to focus the comment")));
         }
     }
 });
@@ -325,17 +337,17 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.CollapseAll,
             title: {
-                value: ( localize(6367, "Collapse All Comments")),
-                original: 'Collapse All Comments'
+                value: ( localize(6676, "Collapse All Comments")),
+                original: "Collapse All Comments"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.WorkspaceHasCommenting
-                }]
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.WorkspaceHasCommenting
+            }]
         });
     }
     run(accessor, ...args) {
@@ -348,17 +360,17 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.ExpandAll,
             title: {
-                value: ( localize(6368, "Expand All Comments")),
-                original: 'Expand All Comments'
+                value: ( localize(6677, "Expand All Comments")),
+                original: "Expand All Comments"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.WorkspaceHasCommenting
-                }]
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.WorkspaceHasCommenting
+            }]
         });
     }
     run(accessor, ...args) {
@@ -371,22 +383,22 @@ registerAction2(class extends Action2 {
         super({
             id: CommentCommandId.ExpandUnresolved,
             title: {
-                value: ( localize(6369, "Expand Unresolved Comments")),
-                original: 'Expand Unresolved Comments'
+                value: ( localize(6678, "Expand Unresolved Comments")),
+                original: "Expand Unresolved Comments"
             },
             category: {
-                value: ( localize(6359, "Comments")),
-                original: 'Comments'
+                value: ( localize(6668, "Comments")),
+                original: "Comments"
             },
             menu: [{
-                    id: MenuId.CommandPalette,
-                    when: CommentContextKeys.WorkspaceHasCommenting
-                }]
+                id: MenuId.CommandPalette,
+                when: CommentContextKeys.WorkspaceHasCommenting
+            }]
         });
     }
     run(accessor, ...args) {
         const commentService = accessor.get(ICommentService);
-        changeAllCollapseState(commentService, (commentThread) => {
+        changeAllCollapseState(commentService, commentThread => {
             return commentThread.state === CommentThreadState.Unresolved ? CommentThreadCollapsibleState.Expanded : CommentThreadCollapsibleState.Collapsed;
         });
     }
@@ -412,32 +424,49 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
     handler: async (accessor, args) => {
         const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
         const keybindingService = accessor.get(IKeybindingService);
+        const notificationService = accessor.get(INotificationService);
+        const commentService = accessor.get(ICommentService);
         await keybindingService.enableKeybindingHoldMode(CommentCommandId.Hide);
         if (activeCodeEditor instanceof SimpleCommentEditor) {
             activeCodeEditor.getParentThread().collapse();
-        }
-        else if (activeCodeEditor) {
+        } else if (activeCodeEditor) {
             const controller = CommentController.get(activeCodeEditor);
             if (!controller) {
                 return;
             }
-            const notificationService = accessor.get(INotificationService);
-            const commentService = accessor.get(ICommentService);
             let error = false;
             try {
                 const activeComment = commentService.lastActiveCommentcontroller?.activeComment;
                 if (!activeComment) {
                     error = true;
-                }
-                else {
+                } else {
                     controller.collapseAndFocusRange(activeComment.thread.threadId);
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 error = true;
             }
             if (error) {
-                notificationService.error(( localize(6366, "The cursor must be on a line with a comment to focus the comment")));
+                notificationService.error(( localize(6675, "The cursor must be on a line with a comment to focus the comment")));
+            }
+        }
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: CommentCommandId.Hide,
+    weight: KeybindingWeight.EditorContrib,
+    primary: KeyMod.CtrlCmd | KeyCode.Escape,
+    win: {
+        primary: KeyMod.Alt | KeyCode.Backspace
+    },
+    when: ( ContextKeyExpr.and(EditorContextKeys.focus, CommentContextKeys.commentWidgetVisible)),
+    handler: async (accessor, args) => {
+        const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+        const keybindingService = accessor.get(IKeybindingService);
+        await keybindingService.enableKeybindingHoldMode(CommentCommandId.Hide);
+        if (activeCodeEditor) {
+            const controller = CommentController.get(activeCodeEditor);
+            if (controller) {
+                await controller.collapseVisibleComments();
             }
         }
     }
@@ -447,8 +476,7 @@ function getActiveEditor(accessor) {
     if (isDiffEditor(activeTextEditorControl)) {
         if (activeTextEditorControl.getOriginalEditor().hasTextFocus()) {
             activeTextEditorControl = activeTextEditorControl.getOriginalEditor();
-        }
-        else {
+        } else {
             activeTextEditorControl = activeTextEditorControl.getModifiedEditor();
         }
     }

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

@@ -11,35 +11,36 @@ import { applyTextEditorOptions } from '@codingame/monaco-vscode-api/vscode/vs/w
 import { SimpleCommentEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/comments/browser/simpleCommentEditor';
 
 let CommentsInputContentProvider = class CommentsInputContentProvider extends Disposable {
-    static { this.ID = 'comments.input.contentProvider'; }
+    static {
+        this.ID = "comments.input.contentProvider";
+    }
     constructor(textModelService, codeEditorService, _modelService, _languageService) {
         super();
         this._modelService = _modelService;
         this._languageService = _languageService;
-        this._register(textModelService.registerTextModelContentProvider(Schemas.commentsInput, this));
-        this._register(codeEditorService.registerCodeEditorOpenHandler(async (input, editor, _sideBySide) => {
-            if (!(editor instanceof SimpleCommentEditor)) {
-                return null;
-            }
-            if (editor.getModel()?.uri.toString() !== ( input.resource.toString())) {
-                return null;
-            }
-            if (input.options) {
-                applyTextEditorOptions(input.options, editor, ScrollType.Immediate);
-            }
-            return editor;
-        }));
+        this._register(
+            textModelService.registerTextModelContentProvider(Schemas.commentsInput, this)
+        );
+        this._register(
+            codeEditorService.registerCodeEditorOpenHandler(async (input, editor, _sideBySide) => {
+                if (!(editor instanceof SimpleCommentEditor)) {
+                    return null;
+                }
+                if (editor.getModel()?.uri.toString() !== ( input.resource.toString())) {
+                    return null;
+                }
+                if (input.options) {
+                    applyTextEditorOptions(input.options, editor, ScrollType.Immediate);
+                }
+                return editor;
+            })
+        );
     }
     async provideTextContent(resource) {
         const existing = this._modelService.getModel(resource);
-        return existing ?? this._modelService.createModel('', this._languageService.createById('markdown'), resource);
+        return existing ?? this._modelService.createModel("", this._languageService.createById("markdown"), resource);
     }
 };
-CommentsInputContentProvider = ( __decorate([
-    ( __param(0, ITextModelService)),
-    ( __param(1, ICodeEditorService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ILanguageService))
-], CommentsInputContentProvider));
+CommentsInputContentProvider = ( __decorate([( __param(0, ITextModelService)), ( __param(1, ICodeEditorService)), ( __param(2, IModelService)), ( __param(3, ILanguageService))], CommentsInputContentProvider));
 
 export { CommentsInputContentProvider };