@codingame/monaco-vscode-comments-service-override 9.0.3 → 10.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-comments-service-override",
-  "version": "9.0.3",
+  "version": "10.0.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@9.0.3"
+    "vscode": "npm:@codingame/monaco-vscode-api@10.0.1"
   }
 }

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

@@ -9,7 +9,6 @@ import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/lay
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { COMMENTS_SECTION } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentsConfiguration';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
-import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { CommentContextKeys } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentContextKeys';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -61,12 +60,12 @@ let CommentService = class CommentService extends Disposable {
         this._handleZenMode();
         this._workspaceHasCommenting = CommentContextKeys.WorkspaceHasCommenting.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(1 , CONTINUE_ON_COMMENTS, storageListener), (last, event) => last?.external ? last : event, 500);
         storageListener.add(storageEvent(v => {
             if (!v.external) {
                 return;
             }
-            const commentsToRestore = this.storageService.getObject(CONTINUE_ON_COMMENTS, StorageScope.WORKSPACE);
+            const commentsToRestore = this.storageService.getObject(CONTINUE_ON_COMMENTS, 1 );
             if (!commentsToRestore) {
                 return;
             }
@@ -148,6 +147,9 @@ let CommentService = class CommentService extends Disposable {
     setActiveEditingCommentThread(commentThread) {
         this._onDidChangeActiveEditingCommentThread.fire(commentThread);
     }
+    get lastActiveCommentcontroller() {
+        return this._lastActiveCommentController;
+    }
     async setActiveCommentAndThread(uniqueOwner, commentInfo) {
         const commentController = this._commentControls.get(uniqueOwner);
         if (!commentController) {
@@ -310,7 +312,7 @@ let CommentService = class CommentService extends Disposable {
             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.storageService.store(CONTINUE_ON_COMMENTS, commentsToSave, 1 , 0 );
     }
     removeContinueOnComment(pendingComment) {
         const pendingComments = this._continueOnComments.get(pendingComment.uniqueOwner);

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

@@ -1,6 +1,5 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { localize } from 'vscode/vscode/vs/nls';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import './commentsEditorContribution.js';
 import './commentService.js';
@@ -13,7 +12,6 @@ import { NumberBadge } from 'vscode/vscode/vs/workbench/services/activity/common
 import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
 import { COMMENTS_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
 import { CommentThreadState } from 'vscode/vscode/vs/editor/common/languages';
-import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { registerAction2, MenuId, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { CONTEXT_KEY_HAS_COMMENTS, CONTEXT_KEY_SOME_COMMENTS_EXPANDED } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsView';
 import { ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
@@ -22,9 +20,8 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { revealCommentThread } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsController';
 import { accessibleViewIsShown, accessibleViewCurrentProviderId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
-import { AccessibleViewProviderId } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
 import { AccessibleViewRegistry } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
-import { CommentsAccessibleView } from './commentsAccessibleView.js';
+import { CommentsAccessibleView, CommentThreadAccessibleView } from './commentsAccessibleView.js';
 import { CommentsAccessibilityHelp } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsAccessibility';
 
 registerAction2(class Collapse extends ViewAction {
@@ -32,7 +29,7 @@ registerAction2(class Collapse extends ViewAction {
         super({
             viewId: COMMENTS_VIEW_ID,
             id: 'comments.collapse',
-            title: ( localize(2130, "Collapse All")),
+            title: ( localize(2141, "Collapse All")),
             f1: false,
             icon: Codicon.collapseAll,
             menu: {
@@ -55,7 +52,7 @@ registerAction2(class Expand extends ViewAction {
         super({
             viewId: COMMENTS_VIEW_ID,
             id: 'comments.expand',
-            title: ( localize(2131, "Expand All")),
+            title: ( localize(2142, "Expand All")),
             f1: false,
             icon: Codicon.expandAll,
             menu: {
@@ -77,7 +74,7 @@ registerAction2(class Reply extends Action2 {
     constructor() {
         super({
             id: 'comments.reply',
-            title: ( localize(2132, "Reply")),
+            title: ( localize(2143, "Reply")),
             icon: Codicon.reply,
             precondition: ( (ContextKeyExpr.equals('canReply', true))),
             menu: [{
@@ -86,10 +83,10 @@ registerAction2(class Reply extends Action2 {
                 },
                 {
                     id: MenuId.AccessibleView,
-                    when: ( (ContextKeyExpr.and(
-                        accessibleViewIsShown,
-                         (ContextKeyExpr.equals(accessibleViewCurrentProviderId.key, AccessibleViewProviderId.Comments))
-                    ))),
+                    when: ( (ContextKeyExpr.and(accessibleViewIsShown,  (ContextKeyExpr.equals(
+                        accessibleViewCurrentProviderId.key,
+                        "comments"
+                    ))))),
                 }]
         });
     }
@@ -103,34 +100,34 @@ registerAction2(class Reply extends Action2 {
 ( (Registry.as(Extensions.Configuration))).registerConfiguration({
     id: 'comments',
     order: 20,
-    title: ( localize(2133, "Comments")),
+    title: ( localize(2144, "Comments")),
     type: 'object',
     properties: {
         'comments.openPanel': {
             enum: ['neverOpen', 'openOnSessionStart', 'openOnSessionStartWithComments'],
             default: 'openOnSessionStartWithComments',
-            description: ( localize(2134, "Controls when the comments panel should open.")),
+            description: ( localize(2145, "Controls when the comments panel should open.")),
             restricted: false,
-            markdownDeprecationMessage: ( localize(2135, "This setting is deprecated in favor of `comments.openView`."))
+            markdownDeprecationMessage: ( localize(2146, "This setting is deprecated in favor of `comments.openView`."))
         },
         'comments.openView': {
             enum: ['never', 'file', 'firstFile', 'firstFileUnresolved'],
-            enumDescriptions: [( localize(2136, "The comments view will never be opened.")), ( localize(2137, "The comments view will open when a file with comments is active.")), ( localize(
-                2138,
+            enumDescriptions: [( localize(2147, "The comments view will never be opened.")), ( localize(2148, "The comments view will open when a file with comments is active.")), ( localize(
+                2149,
                 "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(
-                2139,
+                2150,
                 "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(2140, "Controls when the comments view should open.")),
+            description: ( localize(2151, "Controls when the comments view should open.")),
             restricted: false
         },
         'comments.useRelativeTime': {
             type: 'boolean',
             default: true,
             description: ( localize(
-                2141,
+                2152,
                 "Determines if relative time will be used in comment timestamps (ex. '1 day ago')."
             ))
         },
@@ -138,20 +135,20 @@ registerAction2(class Reply extends Action2 {
             type: 'boolean',
             default: true,
             description: ( localize(
-                2142,
+                2153,
                 "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',
             default: true,
-            description: ( localize(2143, "Controls whether the comments widget scrolls or expands."))
+            description: ( localize(2154, "Controls whether the comments widget scrolls or expands."))
         },
         'comments.collapseOnResolve': {
             type: 'boolean',
             default: true,
             description: ( localize(
-                2144,
+                2155,
                 "Controls whether the comment thread should collapse when the thread is resolved."
             ))
         }
@@ -192,7 +189,7 @@ let UnresolvedCommentsBadge = class UnresolvedCommentsBadge extends Disposable {
             return;
         }
         this.totalUnresolved = unresolved;
-        const message = ( localize(2145, '{0} Unresolved Comments', this.totalUnresolved));
+        const message = ( localize(2156, '{0} Unresolved Comments', this.totalUnresolved));
         this.activity.value = this.activityService.showViewActivity(COMMENTS_VIEW_ID, { badge: ( (new NumberBadge(this.totalUnresolved, () => message))) });
     }
 };
@@ -200,8 +197,9 @@ UnresolvedCommentsBadge = ( (__decorate([
     ( (__param(0, ICommentService))),
     ( (__param(1, IActivityService)))
 ], UnresolvedCommentsBadge)));
-( (Registry.as(Extensions$1.Workbench))).registerWorkbenchContribution(UnresolvedCommentsBadge, LifecyclePhase.Eventually);
+( (Registry.as(Extensions$1.Workbench))).registerWorkbenchContribution(UnresolvedCommentsBadge, 4 );
 AccessibleViewRegistry.register(( (new CommentsAccessibleView())));
+AccessibleViewRegistry.register(( (new CommentThreadAccessibleView())));
 AccessibleViewRegistry.register(( (new CommentsAccessibilityHelp())));
 
 export { UnresolvedCommentsBadge };

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

@@ -1,12 +1,17 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { MarshalledId } from 'vscode/vscode/vs/base/common/marshallingIds';
-import { AccessibleViewType, AccessibleViewProviderId } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
 import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
-import { AccessibilityVerbositySettingId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
 import { COMMENTS_VIEW_ID, CommentsMenus } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
 import { CONTEXT_KEY_COMMENT_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsView';
 import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
+import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service';
+import { CommentContextKeys } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentContextKeys';
+import { revealCommentThread, moveToNextCommentInThread } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsController';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
 
 class CommentsAccessibleView extends Disposable {
     getProvider(accessor) {
@@ -27,7 +32,26 @@ class CommentsAccessibleView extends Disposable {
         this.priority = 90;
         this.name = 'comment';
         this.when = CONTEXT_KEY_COMMENT_FOCUSED;
-        this.type = AccessibleViewType.View;
+        this.type = "view" ;
+    }
+}
+class CommentThreadAccessibleView extends Disposable {
+    getProvider(accessor) {
+        const commentService = accessor.get(ICommentService);
+        const editorService = accessor.get(IEditorService);
+        const uriIdentityService = accessor.get(IUriIdentityService);
+        const threads = commentService.commentsModel.hasCommentThreads();
+        if (!threads) {
+            return;
+        }
+        return ( new CommentsThreadWidgetAccessibleContentProvider(commentService, editorService, uriIdentityService));
+    }
+    constructor() {
+        super();
+        this.priority = 85;
+        this.name = 'commentThread';
+        this.when = CommentContextKeys.commentFocused;
+        this.type = "view" ;
     }
 }
 class CommentsAccessibleContentProvider extends Disposable {
@@ -36,9 +60,9 @@ class CommentsAccessibleContentProvider extends Disposable {
         this._commentsView = _commentsView;
         this._focusedCommentNode = _focusedCommentNode;
         this._menus = _menus;
-        this.id = AccessibleViewProviderId.Comments;
-        this.verbositySettingKey = AccessibilityVerbositySettingId.Comments;
-        this.options = { type: AccessibleViewType.View };
+        this.id = "comments" ;
+        this.verbositySettingKey = "accessibility.verbosity.comments" ;
+        this.options = { type: "view"  };
         this.actions = ( [...this._menus.getResourceContextActions(this._focusedCommentNode)].filter(i => i.enabled).map(action => {
             return {
                 ...action,
@@ -46,7 +70,7 @@ class CommentsAccessibleContentProvider extends Disposable {
                     this._commentsView.focus();
                     action.run({
                         thread: this._focusedCommentNode.thread,
-                        $mid: MarshalledId.CommentThread,
+                        $mid: 7 ,
                         commentControlHandle: this._focusedCommentNode.controllerHandle,
                         commentThreadHandle: this._focusedCommentNode.threadHandle,
                     });
@@ -74,5 +98,71 @@ class CommentsAccessibleContentProvider extends Disposable {
         return this.provideContent();
     }
 }
+let CommentsThreadWidgetAccessibleContentProvider = class CommentsThreadWidgetAccessibleContentProvider extends Disposable {
+    constructor(_commentService, _editorService, _uriIdentityService) {
+        super();
+        this._commentService = _commentService;
+        this._editorService = _editorService;
+        this._uriIdentityService = _uriIdentityService;
+        this.id = "commentThread" ;
+        this.verbositySettingKey = "accessibility.verbosity.comments" ;
+        this.options = { type: "view"  };
+    }
+    get activeCommentInfo() {
+        if (!this._activeCommentInfo && this._commentService.lastActiveCommentcontroller) {
+            this._activeCommentInfo = this._commentService.lastActiveCommentcontroller.activeComment;
+        }
+        return this._activeCommentInfo;
+    }
+    provideContent() {
+        if (!this.activeCommentInfo) {
+            throw ( new Error('No current comment thread'));
+        }
+        const comment = this.activeCommentInfo.comment?.body;
+        const commentLabel = typeof comment === 'string' ? comment : comment?.value ?? '';
+        const resource = this.activeCommentInfo.thread.resource;
+        const range = this.activeCommentInfo.thread.range;
+        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;
+                }
+            }
+        }
+        return commentLabel + contentLabel;
+    }
+    onClose() {
+        const lastComment = this._activeCommentInfo;
+        this._activeCommentInfo = undefined;
+        if (lastComment) {
+            revealCommentThread(this._commentService, this._editorService, this._uriIdentityService, lastComment.thread, lastComment.comment);
+        }
+    }
+    provideNextContent() {
+        const newCommentInfo = moveToNextCommentInThread(this._activeCommentInfo, 'next');
+        if (newCommentInfo) {
+            this._activeCommentInfo = newCommentInfo;
+            return this.provideContent();
+        }
+        return undefined;
+    }
+    providePreviousContent() {
+        const newCommentInfo = moveToNextCommentInThread(this._activeCommentInfo, 'previous');
+        if (newCommentInfo) {
+            this._activeCommentInfo = newCommentInfo;
+            return this.provideContent();
+        }
+        return undefined;
+    }
+};
+CommentsThreadWidgetAccessibleContentProvider = ( __decorate([
+    ( __param(0, ICommentService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IUriIdentityService))
+], CommentsThreadWidgetAccessibleContentProvider));
 
-export { CommentsAccessibleView };
+export { CommentThreadAccessibleView, CommentsAccessibleView };

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

@@ -1,15 +1,15 @@
-import { KeyMod, KeyCode, KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
+import { KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
 import 'vscode/vscode/vs/workbench/contrib/comments/browser/media/review.css';
 import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { registerEditorContribution, EditorContributionInstantiation } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { localize } from 'vscode/vscode/vs/nls';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { KeybindingsRegistry, KeybindingWeight } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { KeybindingsRegistry } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
 import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service';
 import { ctxCommentEditorFocused, SimpleCommentEditor } from 'vscode/vscode/vs/workbench/contrib/comments/browser/simpleCommentEditor';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
-import { MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { registerAction2, Action2, MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
 import { ID, CommentController } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsController';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
@@ -18,15 +18,14 @@ import { CommentContextKeys } from 'vscode/vscode/vs/workbench/contrib/comments/
 import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from 'vscode/vscode/vs/platform/accessibility/common/accessibility';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { accessibilityHelpIsShown, accessibleViewCurrentProviderId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
-import { CommentCommandId } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentCommandIds';
-import { registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
 import { CommentsInputContentProvider } from './commentsInputContentProvider.js';
-import { AccessibleViewProviderId } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
+import { CommentWidgetFocus } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentThreadZoneWidget';
 
-registerEditorContribution(ID, CommentController, EditorContributionInstantiation.AfterFirstRender);
-registerWorkbenchContribution2(CommentsInputContentProvider.ID, CommentsInputContentProvider, WorkbenchPhase.BlockRestore);
+registerEditorContribution(ID, CommentController, 1 );
+registerWorkbenchContribution2(CommentsInputContentProvider.ID, CommentsInputContentProvider, 2 );
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: CommentCommandId.NextThread,
+    id: "editor.action.nextCommentThreadAction" ,
     handler: async (accessor, args) => {
         const activeEditor = getActiveEditor(accessor);
         if (!activeEditor) {
@@ -36,13 +35,13 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         if (!controller) {
             return Promise.resolve();
         }
-        controller.nextCommentThread();
+        controller.nextCommentThread(true);
     },
-    weight: KeybindingWeight.EditorContrib,
-    primary: KeyMod.Alt | KeyCode.F9,
+    weight: 100 ,
+    primary: 512  | 67 ,
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: CommentCommandId.PreviousThread,
+    id: "editor.action.previousCommentThreadAction" ,
     handler: async (accessor, args) => {
         const activeEditor = getActiveEditor(accessor);
         if (!activeEditor) {
@@ -52,13 +51,77 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         if (!controller) {
             return Promise.resolve();
         }
-        controller.previousCommentThread();
+        controller.previousCommentThread(true);
     },
-    weight: KeybindingWeight.EditorContrib,
-    primary: KeyMod.Shift | KeyMod.Alt | KeyCode.F9
+    weight: 100 ,
+    primary: 1024  | 512  | 67
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "editor.action.nextCommentedRangeAction" ,
+            title: {
+                value: ( localize(5327, "Go to Next Commented Range")),
+                original: 'Go to Next Commented Range'
+            },
+            category: {
+                value: ( localize(5328, "Comments")),
+                original: 'Comments'
+            },
+            f1: true,
+            keybinding: {
+                primary: 512  | 68 ,
+                weight: 100 ,
+                when: CommentContextKeys.activeEditorHasCommentingRange
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return;
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return;
+        }
+        controller.nextCommentThread(false);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "editor.action.previousCommentedRangeAction" ,
+            title: {
+                value: ( localize(5329, "Go to Previous Commented Range")),
+                original: 'Go to Previous Commented Range'
+            },
+            category: {
+                value: ( localize(5328, "Comments")),
+                original: 'Comments'
+            },
+            f1: true,
+            keybinding: {
+                primary: 1024  | 512  | 68 ,
+                weight: 100 ,
+                when: CommentContextKeys.activeEditorHasCommentingRange
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return;
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return;
+        }
+        controller.previousCommentThread(false);
+    }
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: CommentCommandId.NextRange,
+    id: "editor.action.nextCommentingRange" ,
     handler: async (accessor, args) => {
         const activeEditor = getActiveEditor(accessor);
         if (!activeEditor) {
@@ -75,22 +138,22 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         CommentContextKeys.commentFocused,
          (ContextKeyExpr.and(
             accessibilityHelpIsShown,
-             (accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Comments))
+             (accessibleViewCurrentProviderId.isEqualTo("comments" ))
         ))
     ))))),
-    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.DownArrow),
-    weight: KeybindingWeight.EditorContrib
+    primary: KeyChord(2048  | 41 , 2048  | 512  | 18 ),
+    weight: 100
 });
 MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
     command: {
-        id: CommentCommandId.NextRange,
-        title: ( localize(5291, "Go to Next Commenting Range")),
+        id: "editor.action.nextCommentingRange" ,
+        title: ( localize(5330, "Go to Next Commenting Range")),
         category: 'Comments',
     },
     when: CommentContextKeys.activeEditorHasCommentingRange
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: CommentCommandId.PreviousRange,
+    id: "editor.action.previousCommentingRange" ,
     handler: async (accessor, args) => {
         const activeEditor = getActiveEditor(accessor);
         if (!activeEditor) {
@@ -107,22 +170,22 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         CommentContextKeys.commentFocused,
          (ContextKeyExpr.and(
             accessibilityHelpIsShown,
-             (accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Comments))
+             (accessibleViewCurrentProviderId.isEqualTo("comments" ))
         ))
     ))))),
-    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.UpArrow),
-    weight: KeybindingWeight.EditorContrib
+    primary: KeyChord(2048  | 41 , 2048  | 512  | 16 ),
+    weight: 100
 });
 MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
     command: {
-        id: CommentCommandId.PreviousRange,
-        title: ( localize(5292, "Go to Previous Commenting Range")),
+        id: "editor.action.previousCommentingRange" ,
+        title: ( localize(5331, "Go to Previous Commenting Range")),
         category: 'Comments',
     },
     when: CommentContextKeys.activeEditorHasCommentingRange
 });
 CommandsRegistry.registerCommand({
-    id: CommentCommandId.ToggleCommenting,
+    id: "workbench.action.toggleCommenting" ,
     handler: (accessor) => {
         const commentService = accessor.get(ICommentService);
         const enable = commentService.isCommentingEnabled;
@@ -131,14 +194,14 @@ CommandsRegistry.registerCommand({
 });
 MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
     command: {
-        id: CommentCommandId.ToggleCommenting,
-        title: ( localize(5293, "Toggle Editor Commenting")),
+        id: "workbench.action.toggleCommenting" ,
+        title: ( localize(5332, "Toggle Editor Commenting")),
         category: 'Comments',
     },
     when: CommentContextKeys.WorkspaceHasCommenting
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: CommentCommandId.Add,
+    id: "workbench.action.addComment" ,
     handler: async (accessor, args) => {
         const activeEditor = getActiveEditor(accessor);
         if (!activeEditor) {
@@ -160,66 +223,111 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
             await controller.addOrToggleCommentAtLine(position, undefined);
         }
         catch (e) {
-            notificationService.error(( localize(5294, "The cursor must be within a commenting range to add a comment")));
+            notificationService.error(( localize(5333, "The cursor must be within a commenting range to add a comment")));
         }
     },
-    weight: KeybindingWeight.EditorContrib,
-    primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyC),
+    weight: 100 ,
+    primary: KeyChord(2048  | 41 , 2048  | 512  | 33 ),
 });
 MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
     command: {
-        id: CommentCommandId.Add,
-        title: ( localize(5295, "Add Comment on Current Selection")),
+        id: "workbench.action.addComment" ,
+        title: ( localize(5334, "Add Comment on Current Selection")),
         category: 'Comments'
     },
     when: CommentContextKeys.activeCursorHasCommentingRange
 });
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.focusCommentOnCurrentLine" ,
+            title: {
+                value: ( localize(5335, "Focus Comment on Current Line")),
+                original: 'Focus Comment on Current Line'
+            },
+            category: {
+                value: ( localize(5328, "Comments")),
+                original: 'Comments'
+            },
+            f1: true,
+            precondition: CommentContextKeys.activeCursorHasComment,
+        });
+    }
+    async run(accessor, ...args) {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return;
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return;
+        }
+        const position = activeEditor.getSelection();
+        const notificationService = accessor.get(INotificationService);
+        let error = false;
+        try {
+            const commentAtLine = controller.getCommentsAtLine(position);
+            if (commentAtLine.length === 0) {
+                error = true;
+            }
+            else {
+                await controller.revealCommentThread(commentAtLine[0].commentThread.threadId, undefined, false, CommentWidgetFocus.Widget);
+            }
+        }
+        catch (e) {
+            error = true;
+        }
+        if (error) {
+            notificationService.error(( localize(5336, "The cursor must be on a line with a comment to focus the comment")));
+        }
+    }
+});
 CommandsRegistry.registerCommand({
-    id: CommentCommandId.CollapseAll,
+    id: "workbench.action.collapseAllComments" ,
     handler: (accessor) => {
         return getActiveController(accessor)?.collapseAll();
     }
 });
 MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
     command: {
-        id: CommentCommandId.CollapseAll,
-        title: ( localize(5296, "Collapse All Comments")),
+        id: "workbench.action.collapseAllComments" ,
+        title: ( localize(5337, "Collapse All Comments")),
         category: 'Comments'
     },
     when: CommentContextKeys.WorkspaceHasCommenting
 });
 CommandsRegistry.registerCommand({
-    id: CommentCommandId.ExpandAll,
+    id: "workbench.action.expandAllComments" ,
     handler: (accessor) => {
         return getActiveController(accessor)?.expandAll();
     }
 });
 MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
     command: {
-        id: CommentCommandId.ExpandAll,
-        title: ( localize(5297, "Expand All Comments")),
+        id: "workbench.action.expandAllComments" ,
+        title: ( localize(5338, "Expand All Comments")),
         category: 'Comments'
     },
     when: CommentContextKeys.WorkspaceHasCommenting
 });
 CommandsRegistry.registerCommand({
-    id: CommentCommandId.ExpandUnresolved,
+    id: "workbench.action.expandUnresolvedComments" ,
     handler: (accessor) => {
         return getActiveController(accessor)?.expandUnresolved();
     }
 });
 MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
     command: {
-        id: CommentCommandId.ExpandUnresolved,
-        title: ( localize(5298, "Expand Unresolved Comments")),
+        id: "workbench.action.expandUnresolvedComments" ,
+        title: ( localize(5339, "Expand Unresolved Comments")),
         category: 'Comments'
     },
     when: CommentContextKeys.WorkspaceHasCommenting
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: CommentCommandId.Submit,
-    weight: KeybindingWeight.EditorContrib,
-    primary: KeyMod.CtrlCmd | KeyCode.Enter,
+    id: "editor.action.submitComment" ,
+    weight: 100 ,
+    primary: 2048  | 3 ,
     when: ctxCommentEditorFocused,
     handler: (accessor, args) => {
         const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
@@ -229,10 +337,10 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
     }
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: CommentCommandId.Hide,
-    weight: KeybindingWeight.EditorContrib,
-    primary: KeyCode.Escape,
-    secondary: [KeyMod.Shift | KeyCode.Escape],
+    id: "workbench.action.hideComment" ,
+    weight: 100 ,
+    primary: 9 ,
+    secondary: [1024  | 9 ],
     when: ctxCommentEditorFocused,
     handler: (accessor, args) => {
         const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();

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

@@ -2,7 +2,6 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { ScrollType } from 'vscode/vscode/vs/editor/common/editorCommon';
 import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
 import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
@@ -24,7 +23,7 @@ let CommentsInputContentProvider = class CommentsInputContentProvider extends Di
                 return null;
             }
             if (input.options) {
-                applyTextEditorOptions(input.options, editor, ScrollType.Immediate);
+                applyTextEditorOptions(input.options, editor, 1 );
             }
             return editor;
         }));