@codingame/monaco-vscode-comments-service-override 11.1.2 → 12.0.1

package/index.d.ts

@@ -1 +1,2 @@
-export { default } from 'vscode/service-override/comments';
+import { type IEditorOverrideServices } from "vscode/vscode/vs/editor/standalone/browser/standaloneServices";
+export default function getServiceOverride(): IEditorOverrideServices;

package/index.js

@@ -1 +1,14 @@
-export { default } from './comments.js';
+
+import 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service';
+import { CommentService } from './vscode/src/vs/workbench/contrib/comments/browser/commentService.js';
+import './vscode/src/vs/workbench/contrib/comments/browser/comments.contribution.js';
+
+function getServiceOverride() {
+    return {
+        [ICommentService.toString()]: new SyncDescriptor(CommentService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@codingame/monaco-vscode-comments-service-override",
-  "version": "11.1.2",
+  "version": "12.0.1",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - comments service-override",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -12,8 +14,22 @@
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
-  "private": false,
-  "description": "VSCode public API plugged on the monaco editor - comments service-override",
+  "dependencies": {
+    "@codingame/monaco-vscode-219d9a5f-b446-507b-a188-1178a0867c75-common": "12.0.1",
+    "@codingame/monaco-vscode-65619f8f-0eab-5d8b-855a-43b6353fe527-common": "12.0.1",
+    "@codingame/monaco-vscode-9ee79c1a-3f03-568b-8eac-b02513a98b68-common": "12.0.1",
+    "@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-common": "12.0.1",
+    "@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common": "12.0.1",
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.1"
+  },
+  "peerDependencies": {
+    "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common": "12.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common": {
+      "optional": true
+    }
+  },
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -22,12 +38,12 @@
       "default": "./index.js"
     },
     "./vscode/*": {
-      "default": "./vscode/src/*.js"
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
     }
-  },
-  "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@11.1.2",
-    "@codingame/monaco-vscode-chat-comments-extensions-interactive-notebook-search-common": "11.1.2",
-    "@codingame/monaco-vscode-comments-extensions-common": "11.1.2"
   }
 }

package/vscode/src/vs/workbench/contrib/comments/browser/commentMenus.d.ts

@@ -0,0 +1,18 @@
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { Comment } from "vscode/vscode/vs/editor/common/languages";
+import { IMenu } from "vscode/vscode/vs/platform/actions/common/actions";
+import { IMenuService } from "vscode/vscode/vs/platform/actions/common/actions.service";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+export declare class CommentMenus implements IDisposable {
+    private readonly menuService;
+    constructor(menuService: IMenuService);
+    getCommentThreadTitleActions(contextKeyService: IContextKeyService): IMenu;
+    getCommentThreadActions(contextKeyService: IContextKeyService): IMenu;
+    getCommentEditorActions(contextKeyService: IContextKeyService): IMenu;
+    getCommentThreadAdditionalActions(contextKeyService: IContextKeyService): IMenu;
+    getCommentTitleActions(comment: Comment, contextKeyService: IContextKeyService): IMenu;
+    getCommentActions(comment: Comment, contextKeyService: IContextKeyService): IMenu;
+    getCommentThreadTitleContextActions(contextKeyService: IContextKeyService): IMenu;
+    private getMenu;
+    dispose(): void;
+}

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

@@ -1,7 +1,7 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
-import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
 
 let CommentMenus = class CommentMenus {
     constructor(menuService) {
@@ -17,7 +17,7 @@ let CommentMenus = class CommentMenus {
         return this.getMenu(MenuId.CommentEditorActions, contextKeyService);
     }
     getCommentThreadAdditionalActions(contextKeyService) {
-        return this.getMenu(MenuId.CommentThreadAdditionalActions, contextKeyService);
+        return this.getMenu(MenuId.CommentThreadAdditionalActions, contextKeyService, { emitEventsForSubmenuChanges: true });
     }
     getCommentTitleActions(comment, contextKeyService) {
         return this.getMenu(MenuId.CommentTitle, contextKeyService);
@@ -28,13 +28,8 @@ let CommentMenus = class CommentMenus {
     getCommentThreadTitleContextActions(contextKeyService) {
         return this.getMenu(MenuId.CommentThreadTitleContext, contextKeyService);
     }
-    getMenu(menuId, contextKeyService) {
-        const menu = this.menuService.createMenu(menuId, contextKeyService);
-        const primary = [];
-        const secondary = [];
-        const result = { primary, secondary };
-        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline');
-        return menu;
+    getMenu(menuId, contextKeyService, options) {
+        return this.menuService.createMenu(menuId, contextKeyService, options);
     }
     dispose() {
     }

package/vscode/src/vs/workbench/contrib/comments/browser/commentService.d.ts

@@ -0,0 +1,159 @@
+import { CommentThreadChangedEvent, CommentInfo, Comment, CommentReaction, CommentingRanges, CommentThread, CommentOptions, PendingCommentThread, CommentingRangeResourceHint } from "vscode/vscode/vs/editor/common/languages";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI, UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { Range, IRange } from "vscode/vscode/vs/editor/common/core/range";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { ICommentThreadChangedEvent } from "@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/common/commentModel";
+import { CommentMenus } from "./commentMenus.js";
+import { ICellRange } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { IWorkbenchLayoutService } from "vscode/vscode/vs/workbench/services/layout/browser/layoutService.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { ICommentsModel } from "@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsModel";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+import { ICommentService } from "vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service";
+export interface IResourceCommentThreadEvent {
+    resource: URI;
+    commentInfos: ICommentInfo[];
+}
+export interface ICommentInfo<T = IRange> extends CommentInfo<T> {
+    uniqueOwner: string;
+    label?: string;
+}
+export interface INotebookCommentInfo {
+    extensionId?: string;
+    threads: CommentThread<ICellRange>[];
+    uniqueOwner: string;
+    label?: string;
+}
+export interface IWorkspaceCommentThreadsEvent {
+    ownerId: string;
+    ownerLabel: string;
+    commentThreads: CommentThread[];
+}
+export interface INotebookCommentThreadChangedEvent extends CommentThreadChangedEvent<ICellRange> {
+    uniqueOwner: string;
+}
+export interface ICommentController {
+    id: string;
+    label: string;
+    features: {
+        reactionGroup?: CommentReaction[];
+        reactionHandler?: boolean;
+        options?: CommentOptions;
+    };
+    options?: CommentOptions;
+    contextValue?: string;
+    owner: string;
+    activeComment: {
+        thread: CommentThread;
+        comment?: Comment;
+    } | undefined;
+    createCommentThreadTemplate(resource: UriComponents, range: IRange | undefined, editorId?: string): Promise<void>;
+    updateCommentThreadTemplate(threadHandle: number, range: IRange): Promise<void>;
+    deleteCommentThreadMain(commentThreadId: string): void;
+    toggleReaction(uri: URI, thread: CommentThread, comment: Comment, reaction: CommentReaction, token: CancellationToken): Promise<void>;
+    getDocumentComments(resource: URI, token: CancellationToken): Promise<ICommentInfo<IRange>>;
+    getNotebookComments(resource: URI, token: CancellationToken): Promise<INotebookCommentInfo>;
+    setActiveCommentAndThread(commentInfo: {
+        thread: CommentThread;
+        comment?: Comment;
+    } | undefined): Promise<void>;
+}
+export interface IContinueOnCommentProvider {
+    provideContinueOnComments(): PendingCommentThread[];
+}
+export declare class CommentService extends Disposable implements ICommentService {
+    protected readonly instantiationService: IInstantiationService;
+    private readonly layoutService;
+    private readonly configurationService;
+    private readonly storageService;
+    private readonly logService;
+    private readonly modelService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidSetDataProvider;
+    readonly onDidSetDataProvider: Event<void>;
+    private readonly _onDidDeleteDataProvider;
+    readonly onDidDeleteDataProvider: Event<string | undefined>;
+    private readonly _onDidSetResourceCommentInfos;
+    readonly onDidSetResourceCommentInfos: Event<IResourceCommentThreadEvent>;
+    private readonly _onDidSetAllCommentThreads;
+    readonly onDidSetAllCommentThreads: Event<IWorkspaceCommentThreadsEvent>;
+    private readonly _onDidUpdateCommentThreads;
+    readonly onDidUpdateCommentThreads: Event<ICommentThreadChangedEvent>;
+    private readonly _onDidUpdateNotebookCommentThreads;
+    readonly onDidUpdateNotebookCommentThreads: Event<INotebookCommentThreadChangedEvent>;
+    private readonly _onDidUpdateCommentingRanges;
+    readonly onDidUpdateCommentingRanges: Event<{
+        uniqueOwner: string;
+    }>;
+    private readonly _onDidChangeActiveEditingCommentThread;
+    readonly onDidChangeActiveEditingCommentThread: Event<CommentThread<IRange> | null>;
+    private readonly _onDidChangeCurrentCommentThread;
+    readonly onDidChangeCurrentCommentThread: Event<CommentThread<IRange> | undefined>;
+    private readonly _onDidChangeCommentingEnabled;
+    readonly onDidChangeCommentingEnabled: Event<boolean>;
+    private readonly _onDidChangeActiveCommentingRange;
+    readonly onDidChangeActiveCommentingRange: Event<{
+        range: Range;
+        commentingRangesInfo: CommentingRanges;
+    }>;
+    private _commentControls;
+    private _commentMenus;
+    private _isCommentingEnabled;
+    private _workspaceHasCommenting;
+    private _continueOnComments;
+    private _continueOnCommentProviders;
+    private readonly _commentsModel;
+    readonly commentsModel: ICommentsModel;
+    private _commentingRangeResources;
+    private _commentingRangeResourceHintSchemes;
+    constructor(instantiationService: IInstantiationService, layoutService: IWorkbenchLayoutService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, storageService: IStorageService, logService: ILogService, modelService: IModelService);
+    private _updateResourcesWithCommentingRanges;
+    private _handleConfiguration;
+    private _handleZenMode;
+    private get _defaultCommentingEnablement();
+    get isCommentingEnabled(): boolean;
+    enableCommenting(enable: boolean): void;
+    setCurrentCommentThread(commentThread: CommentThread | undefined): void;
+    setActiveEditingCommentThread(commentThread: CommentThread | null): void;
+    get lastActiveCommentcontroller(): ICommentController | undefined;
+    private _lastActiveCommentController;
+    setActiveCommentAndThread(uniqueOwner: string, commentInfo: {
+        thread: CommentThread<IRange>;
+        comment?: Comment;
+    } | undefined): Promise<void>;
+    setDocumentComments(resource: URI, commentInfos: ICommentInfo[]): void;
+    private setModelThreads;
+    private updateModelThreads;
+    setWorkspaceComments(uniqueOwner: string, commentsByResource: CommentThread[]): void;
+    removeWorkspaceComments(uniqueOwner: string): void;
+    registerCommentController(uniqueOwner: string, commentControl: ICommentController): void;
+    unregisterCommentController(uniqueOwner?: string): void;
+    getCommentController(uniqueOwner: string): ICommentController | undefined;
+    createCommentThreadTemplate(uniqueOwner: string, resource: URI, range: Range | undefined, editorId?: string): Promise<void>;
+    updateCommentThreadTemplate(uniqueOwner: string, threadHandle: number, range: Range): Promise<void>;
+    disposeCommentThread(uniqueOwner: string, threadId: string): void;
+    getCommentMenus(uniqueOwner: string): CommentMenus;
+    updateComments(ownerId: string, event: CommentThreadChangedEvent<IRange>): void;
+    updateNotebookComments(ownerId: string, event: CommentThreadChangedEvent<ICellRange>): void;
+    updateCommentingRanges(ownerId: string, resourceHints?: CommentingRangeResourceHint): void;
+    toggleReaction(uniqueOwner: string, resource: URI, thread: CommentThread, comment: Comment, reaction: CommentReaction): Promise<void>;
+    hasReactionHandler(uniqueOwner: string): boolean;
+    getDocumentComments(resource: URI): Promise<(ICommentInfo | null)[]>;
+    getNotebookComments(resource: URI): Promise<(INotebookCommentInfo | null)[]>;
+    registerContinueOnCommentProvider(provider: IContinueOnCommentProvider): IDisposable;
+    private _saveContinueOnComments;
+    removeContinueOnComment(pendingComment: {
+        range: IRange;
+        uri: URI;
+        uniqueOwner: string;
+        isReply?: boolean;
+    }): PendingCommentThread | undefined;
+    private _addContinueOnComments;
+    resourceHasCommentingRanges(resource: URI): boolean;
+}

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -7,12 +8,13 @@ import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { CommentMenus } from './commentMenus.js';
 import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { COMMENTS_SECTION } from '@codingame/monaco-vscode-chat-comments-extensions-interactive-notebook-search-common/vscode/vs/workbench/contrib/comments/common/commentsConfiguration';
+import { COMMENTS_SECTION } from '@codingame/monaco-vscode-9ee79c1a-3f03-568b-8eac-b02513a98b68-common/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';
-import { CommentsModel } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsModel';
+import { CommentsModel } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsModel';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
 
 const CONTINUE_ON_COMMENTS = 'comments.continueOnComments';
@@ -60,12 +62,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(1 , 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;
             }
-            const commentsToRestore = this.storageService.getObject(CONTINUE_ON_COMMENTS, 1 );
+            const commentsToRestore = this.storageService.getObject(CONTINUE_ON_COMMENTS, StorageScope.WORKSPACE);
             if (!commentsToRestore) {
                 return;
             }
@@ -312,7 +314,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, 1 , 0 );
+        this.storageService.store(CONTINUE_ON_COMMENTS, commentsToSave, StorageScope.WORKSPACE, StorageTarget.USER);
     }
     removeContinueOnComment(pendingComment) {
         const pendingComments = this._continueOnComments.get(pendingComment.uniqueOwner);

package/vscode/src/vs/workbench/contrib/comments/browser/comments.contribution.d.ts

@@ -0,0 +1,14 @@
+import { ICommentService } from "vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IWorkbenchContribution } from "vscode/vscode/vs/workbench/common/contributions";
+import { IActivityService } from "vscode/vscode/vs/workbench/services/activity/common/activity.service";
+export declare class UnresolvedCommentsBadge extends Disposable implements IWorkbenchContribution {
+    private readonly _commentService;
+    private readonly activityService;
+    private readonly activity;
+    private totalUnresolved;
+    constructor(_commentService: ICommentService, activityService: IActivityService);
+    private onAllCommentsChanged;
+    private onCommentsUpdated;
+    private updateBadge;
+}

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

@@ -1,5 +1,7 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 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';
@@ -8,18 +10,20 @@ import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/confi
 import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/contributions';
-import { NumberBadge } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { NumberBadge } from '@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-common/vscode/vs/workbench/services/activity/common/activity';
 import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
-import { COMMENTS_VIEW_ID } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
+import { COMMENTS_VIEW_ID } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/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 '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsView';
-import { ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { CONTEXT_KEY_HAS_COMMENTS, CONTEXT_KEY_SOME_COMMENTS_EXPANDED } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsView';
+import { ViewAction } from '@codingame/monaco-vscode-65619f8f-0eab-5d8b-855a-43b6353fe527-common/vscode/vs/workbench/browser/parts/views/viewPane';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { revealCommentThread } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsController';
+import { revealCommentThread } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/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, CommentThreadAccessibleView } from './commentsAccessibleView.js';
 import { CommentsAccessibilityHelp } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsAccessibility';
@@ -29,16 +33,13 @@ registerAction2(class Collapse extends ViewAction {
         super({
             viewId: COMMENTS_VIEW_ID,
             id: 'comments.collapse',
-            title: ( localize(2138, "Collapse All")),
+            title: ( localize(4817, "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))),
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.and(( ContextKeyExpr.equals('view', COMMENTS_VIEW_ID)), CONTEXT_KEY_HAS_COMMENTS)), CONTEXT_KEY_SOME_COMMENTS_EXPANDED)),
                 order: 100
             }
         });
@@ -52,16 +53,13 @@ registerAction2(class Expand extends ViewAction {
         super({
             viewId: COMMENTS_VIEW_ID,
             id: 'comments.expand',
-            title: ( localize(2139, "Expand All")),
+            title: ( localize(4818, "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)))),
+                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
             }
         });
@@ -74,19 +72,16 @@ registerAction2(class Reply extends Action2 {
     constructor() {
         super({
             id: 'comments.reply',
-            title: ( localize(2140, "Reply")),
+            title: ( localize(4819, "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,
-                        "comments"
-                    ))))),
+                    when: ( ContextKeyExpr.and(accessibleViewIsShown, ( ContextKeyExpr.equals(accessibleViewCurrentProviderId.key, AccessibleViewProviderId.Comments)))),
                 }]
         });
     }
@@ -97,37 +92,37 @@ registerAction2(class Reply extends Action2 {
         revealCommentThread(commentService, editorService, uriIdentityService, marshalledCommentThread.thread, marshalledCommentThread.thread.comments[marshalledCommentThread.thread.comments.length - 1], true);
     }
 });
-( (Registry.as(Extensions.Configuration))).registerConfiguration({
+( Registry.as(Extensions.Configuration)).registerConfiguration({
     id: 'comments',
     order: 20,
-    title: ( localize(2141, "Comments")),
+    title: ( localize(4820, "Comments")),
     type: 'object',
     properties: {
         'comments.openPanel': {
             enum: ['neverOpen', 'openOnSessionStart', 'openOnSessionStartWithComments'],
             default: 'openOnSessionStartWithComments',
-            description: ( localize(2142, "Controls when the comments panel should open.")),
+            description: ( localize(4821, "Controls when the comments panel should open.")),
             restricted: false,
-            markdownDeprecationMessage: ( localize(2143, "This setting is deprecated in favor of `comments.openView`."))
+            markdownDeprecationMessage: ( localize(4822, "This setting is deprecated in favor of `comments.openView`."))
         },
         'comments.openView': {
             enum: ['never', 'file', 'firstFile', 'firstFileUnresolved'],
-            enumDescriptions: [( localize(2144, "The comments view will never be opened.")), ( localize(2145, "The comments view will open when a file with comments is active.")), ( localize(
-                2146,
+            enumDescriptions: [( localize(4823, "The comments view will never be opened.")), ( localize(4824, "The comments view will open when a file with comments is active.")), ( localize(
+                4825,
                 "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(
-                2147,
+                4826,
                 "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(2148, "Controls when the comments view should open.")),
+            description: ( localize(4827, "Controls when the comments view should open.")),
             restricted: false
         },
         'comments.useRelativeTime': {
             type: 'boolean',
             default: true,
             description: ( localize(
-                2149,
+                4828,
                 "Determines if relative time will be used in comment timestamps (ex. '1 day ago')."
             ))
         },
@@ -135,20 +130,20 @@ registerAction2(class Reply extends Action2 {
             type: 'boolean',
             default: true,
             description: ( localize(
-                2150,
+                4829,
                 "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(2151, "Controls whether the comments widget scrolls or expands."))
+            description: ( localize(4830, "Controls whether the comments widget scrolls or expands."))
         },
         'comments.collapseOnResolve': {
             type: 'boolean',
             default: true,
             description: ( localize(
-                2152,
+                4831,
                 "Controls whether the comment thread should collapse when the thread is resolved."
             ))
         }
@@ -159,7 +154,7 @@ let UnresolvedCommentsBadge = class UnresolvedCommentsBadge extends Disposable {
         super();
         this._commentService = _commentService;
         this.activityService = activityService;
-        this.activity = this._register(( (new MutableDisposable())));
+        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));
@@ -189,17 +184,17 @@ let UnresolvedCommentsBadge = class UnresolvedCommentsBadge extends Disposable {
             return;
         }
         this.totalUnresolved = unresolved;
-        const message = ( localize(2153, '{0} Unresolved Comments', this.totalUnresolved));
-        this.activity.value = this.activityService.showViewActivity(COMMENTS_VIEW_ID, { badge: ( (new NumberBadge(this.totalUnresolved, () => message))) });
+        const message = ( localize(4832, '{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)));
-( (Registry.as(Extensions$1.Workbench))).registerWorkbenchContribution(UnresolvedCommentsBadge, 4 );
-AccessibleViewRegistry.register(( (new CommentsAccessibleView())));
-AccessibleViewRegistry.register(( (new CommentThreadAccessibleView())));
-AccessibleViewRegistry.register(( (new CommentsAccessibilityHelp())));
+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()));
+AccessibleViewRegistry.register(( new CommentsAccessibilityHelp()));
 
 export { UnresolvedCommentsBadge };

package/vscode/src/vs/workbench/contrib/comments/browser/commentsAccessibleView.d.ts

@@ -0,0 +1,68 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ServicesAccessor } from "vscode/vscode/vs/editor/browser/editorExtensions";
+import { AccessibleViewProviderId, AccessibleViewType, IAccessibleViewContentProvider } from "vscode/vscode/vs/platform/accessibility/browser/accessibleView";
+import { IAccessibleViewImplentation } from "vscode/vscode/vs/platform/accessibility/browser/accessibleViewRegistry";
+import { AccessibilityVerbositySettingId } from "vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration";
+import { CommentsMenus } from "@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer";
+import { CommentsPanel } from "@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsView";
+import { ICommentService } from "vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+export declare class CommentsAccessibleView extends Disposable implements IAccessibleViewImplentation {
+    readonly priority = 90;
+    readonly name = "comment";
+    readonly when: import("vscode/vscode/vs/platform/contextkey/common/contextkey").RawContextKey<boolean>;
+    readonly type = AccessibleViewType.View;
+    getProvider(accessor: ServicesAccessor): CommentsAccessibleContentProvider | undefined;
+    constructor();
+}
+export declare class CommentThreadAccessibleView extends Disposable implements IAccessibleViewImplentation {
+    readonly priority = 85;
+    readonly name = "commentThread";
+    readonly when: import("vscode/vscode/vs/platform/contextkey/common/contextkey").RawContextKey<boolean>;
+    readonly type = AccessibleViewType.View;
+    getProvider(accessor: ServicesAccessor): CommentsThreadWidgetAccessibleContentProvider | undefined;
+    constructor();
+}
+declare class CommentsAccessibleContentProvider extends Disposable implements IAccessibleViewContentProvider {
+    private readonly _commentsView;
+    private readonly _focusedCommentNode;
+    private readonly _menus;
+    constructor(_commentsView: CommentsPanel, _focusedCommentNode: any, _menus: CommentsMenus);
+    readonly id = AccessibleViewProviderId.Comments;
+    readonly verbositySettingKey = AccessibilityVerbositySettingId.Comments;
+    readonly options: {
+        type: AccessibleViewType;
+    };
+    actions: {
+        run: () => void;
+        id: string;
+        label: string;
+        tooltip: string;
+        class: string | undefined;
+        enabled: boolean;
+        checked?: boolean | undefined;
+    }[];
+    provideContent(): string;
+    onClose(): void;
+    provideNextContent(): string | undefined;
+    providePreviousContent(): string | undefined;
+}
+declare class CommentsThreadWidgetAccessibleContentProvider extends Disposable implements IAccessibleViewContentProvider {
+    private readonly _commentService;
+    private readonly _editorService;
+    private readonly _uriIdentityService;
+    readonly id = AccessibleViewProviderId.CommentThread;
+    readonly verbositySettingKey = AccessibilityVerbositySettingId.Comments;
+    readonly options: {
+        type: AccessibleViewType;
+    };
+    private _activeCommentInfo;
+    constructor(_commentService: ICommentService, _editorService: IEditorService, _uriIdentityService: IUriIdentityService);
+    private get activeCommentInfo();
+    provideContent(): string;
+    onClose(): void;
+    provideNextContent(): string | undefined;
+    providePreviousContent(): string | undefined;
+}
+export {};

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

@@ -1,13 +1,17 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 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 { COMMENTS_VIEW_ID, CommentsMenus } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
-import { CONTEXT_KEY_COMMENT_FOCUSED } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsView';
+import { AccessibilityVerbositySettingId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { COMMENTS_VIEW_ID, CommentsMenus } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
+import { CONTEXT_KEY_COMMENT_FOCUSED } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/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 '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsController';
+import { revealCommentThread, moveToNextCommentInThread } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/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';
@@ -32,7 +36,7 @@ class CommentsAccessibleView extends Disposable {
         this.priority = 90;
         this.name = 'comment';
         this.when = CONTEXT_KEY_COMMENT_FOCUSED;
-        this.type = "view" ;
+        this.type = AccessibleViewType.View;
     }
 }
 class CommentThreadAccessibleView extends Disposable {
@@ -51,7 +55,7 @@ class CommentThreadAccessibleView extends Disposable {
         this.priority = 85;
         this.name = 'commentThread';
         this.when = CommentContextKeys.commentFocused;
-        this.type = "view" ;
+        this.type = AccessibleViewType.View;
     }
 }
 class CommentsAccessibleContentProvider extends Disposable {
@@ -60,9 +64,9 @@ class CommentsAccessibleContentProvider extends Disposable {
         this._commentsView = _commentsView;
         this._focusedCommentNode = _focusedCommentNode;
         this._menus = _menus;
-        this.id = "comments" ;
-        this.verbositySettingKey = "accessibility.verbosity.comments" ;
-        this.options = { type: "view"  };
+        this.id = AccessibleViewProviderId.Comments;
+        this.verbositySettingKey = AccessibilityVerbositySettingId.Comments;
+        this.options = { type: AccessibleViewType.View };
         this.actions = ( [...this._menus.getResourceContextActions(this._focusedCommentNode)].filter(i => i.enabled).map(action => {
             return {
                 ...action,
@@ -70,7 +74,7 @@ class CommentsAccessibleContentProvider extends Disposable {
                     this._commentsView.focus();
                     action.run({
                         thread: this._focusedCommentNode.thread,
-                        $mid: 7 ,
+                        $mid: MarshalledId.CommentThread,
                         commentControlHandle: this._focusedCommentNode.controllerHandle,
                         commentThreadHandle: this._focusedCommentNode.threadHandle,
                     });
@@ -104,9 +108,9 @@ let CommentsThreadWidgetAccessibleContentProvider = class CommentsThreadWidgetAc
         this._commentService = _commentService;
         this._editorService = _editorService;
         this._uriIdentityService = _uriIdentityService;
-        this.id = "commentThread" ;
-        this.verbositySettingKey = "accessibility.verbosity.comments" ;
-        this.options = { type: "view"  };
+        this.id = AccessibleViewProviderId.CommentThread;
+        this.verbositySettingKey = AccessibilityVerbositySettingId.Comments;
+        this.options = { type: AccessibleViewType.View };
     }
     get activeCommentInfo() {
         if (!this._activeCommentInfo && this._commentService.lastActiveCommentcontroller) {

package/vscode/src/vs/workbench/contrib/comments/browser/commentsEditorContribution.d.ts

@@ -0,0 +1,3 @@
+import { IActiveCodeEditor } from "vscode/vscode/vs/editor/browser/editorBrowser";
+import { ServicesAccessor } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+export declare function getActiveEditor(accessor: ServicesAccessor): IActiveCodeEditor | null;

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

@@ -1,30 +1,33 @@
-import { KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
-import '@codingame/monaco-vscode-chat-comments-extensions-interactive-notebook-search-common/vscode/vs/workbench/contrib/comments/browser/media/review.css';
+
+import { KeyMod, KeyCode, KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
+import '@codingame/monaco-vscode-9ee79c1a-3f03-568b-8eac-b02513a98b68-common/vscode/vs/workbench/contrib/comments/browser/media/review.css';
 import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { registerEditorContribution, EditorContributionInstantiation } 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 { KeybindingsRegistry } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { KeybindingsRegistry, KeybindingWeight } 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 { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
-import { ID, CommentController } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsController';
+import { ID, CommentController } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsController';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
 import { CommentContextKeys } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentContextKeys';
 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 { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { CommentCommandId } from 'vscode/vscode/vs/workbench/contrib/comments/common/commentCommandIds';
+import { registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
 import { CommentsInputContentProvider } from './commentsInputContentProvider.js';
-import { CommentWidgetFocus } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentThreadZoneWidget';
+import { AccessibleViewProviderId } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
+import { CommentWidgetFocus } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentThreadZoneWidget';
 
-registerEditorContribution(ID, CommentController, 1 );
-registerWorkbenchContribution2(CommentsInputContentProvider.ID, CommentsInputContentProvider, 2 );
+registerEditorContribution(ID, CommentController, EditorContributionInstantiation.AfterFirstRender);
+registerWorkbenchContribution2(CommentsInputContentProvider.ID, CommentsInputContentProvider, WorkbenchPhase.BlockRestore);
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: "editor.action.nextCommentThreadAction" ,
+    id: CommentCommandId.NextThread,
     handler: async (accessor, args) => {
         const activeEditor = getActiveEditor(accessor);
         if (!activeEditor) {
@@ -36,11 +39,11 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         }
         controller.nextCommentThread(true);
     },
-    weight: 100 ,
-    primary: 512  | 67 ,
+    weight: KeybindingWeight.EditorContrib,
+    primary: KeyMod.Alt | KeyCode.F9,
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: "editor.action.previousCommentThreadAction" ,
+    id: CommentCommandId.PreviousThread,
     handler: async (accessor, args) => {
         const activeEditor = getActiveEditor(accessor);
         if (!activeEditor) {
@@ -52,19 +55,19 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
         }
         controller.previousCommentThread(true);
     },
-    weight: 100 ,
-    primary: 1024  | 512  | 67
+    weight: KeybindingWeight.EditorContrib,
+    primary: KeyMod.Shift | KeyMod.Alt | KeyCode.F9
 });
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "editor.action.nextCommentedRangeAction" ,
+            id: CommentCommandId.NextCommentedRange,
             title: {
-                value: ( localize(5306, "Go to Next Commented Range")),
+                value: ( localize(4851, "Go to Next Commented Range")),
                 original: 'Go to Next Commented Range'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -72,8 +75,8 @@ registerAction2(class extends Action2 {
                     when: CommentContextKeys.activeEditorHasCommentingRange
                 }],
             keybinding: {
-                primary: 512  | 68 ,
-                weight: 100 ,
+                primary: KeyMod.Alt | KeyCode.F10,
+                weight: KeybindingWeight.EditorContrib,
                 when: CommentContextKeys.activeEditorHasCommentingRange
             }
         });
@@ -93,13 +96,13 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "editor.action.previousCommentedRangeAction" ,
+            id: CommentCommandId.PreviousCommentedRange,
             title: {
-                value: ( localize(5308, "Go to Previous Commented Range")),
+                value: ( localize(4853, "Go to Previous Commented Range")),
                 original: 'Go to Previous Commented Range'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -107,8 +110,8 @@ registerAction2(class extends Action2 {
                     when: CommentContextKeys.activeEditorHasCommentingRange
                 }],
             keybinding: {
-                primary: 1024  | 512  | 68 ,
-                weight: 100 ,
+                primary: KeyMod.Shift | KeyMod.Alt | KeyCode.F10,
+                weight: KeybindingWeight.EditorContrib,
                 when: CommentContextKeys.activeEditorHasCommentingRange
             }
         });
@@ -128,13 +131,13 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "editor.action.nextCommentingRange" ,
+            id: CommentCommandId.NextRange,
             title: {
-                value: ( localize(5309, "Go to Next Commenting Range")),
+                value: ( localize(4854, "Go to Next Commenting Range")),
                 original: 'Go to Next Commenting Range'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -142,16 +145,9 @@ registerAction2(class extends Action2 {
                     when: CommentContextKeys.activeEditorHasCommentingRange
                 }],
             keybinding: {
-                primary: KeyChord(2048  | 41 , 2048  | 512  | 18 ),
-                weight: 100 ,
-                when: ( (ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED,  (ContextKeyExpr.or(
-                    EditorContextKeys.focus,
-                    CommentContextKeys.commentFocused,
-                     (ContextKeyExpr.and(
-                        accessibilityHelpIsShown,
-                         (accessibleViewCurrentProviderId.isEqualTo("comments" ))
-                    ))
-                )))))
+                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))))))))
             }
         });
     }
@@ -170,13 +166,13 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "editor.action.previousCommentingRange" ,
+            id: CommentCommandId.PreviousRange,
             title: {
-                value: ( localize(5310, "Go to Previous Commenting Range")),
+                value: ( localize(4855, "Go to Previous Commenting Range")),
                 original: 'Go to Previous Commenting Range'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -184,16 +180,9 @@ registerAction2(class extends Action2 {
                     when: CommentContextKeys.activeEditorHasCommentingRange
                 }],
             keybinding: {
-                primary: KeyChord(2048  | 41 , 2048  | 512  | 16 ),
-                weight: 100 ,
-                when: ( (ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED,  (ContextKeyExpr.or(
-                    EditorContextKeys.focus,
-                    CommentContextKeys.commentFocused,
-                     (ContextKeyExpr.and(
-                        accessibilityHelpIsShown,
-                         (accessibleViewCurrentProviderId.isEqualTo("comments" ))
-                    ))
-                )))))
+                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))))))))
             }
         });
     }
@@ -212,13 +201,13 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "workbench.action.toggleCommenting" ,
+            id: CommentCommandId.ToggleCommenting,
             title: {
-                value: ( localize(5311, "Toggle Editor Commenting")),
+                value: ( localize(4856, "Toggle Editor Commenting")),
                 original: 'Toggle Editor Commenting'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -236,13 +225,13 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "workbench.action.addComment" ,
+            id: CommentCommandId.Add,
             title: {
-                value: ( localize(5312, "Add Comment on Current Selection")),
+                value: ( localize(4857, "Add Comment on Current Selection")),
                 original: 'Add Comment on Current Selection'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -250,8 +239,8 @@ registerAction2(class extends Action2 {
                     when: CommentContextKeys.activeCursorHasCommentingRange
                 }],
             keybinding: {
-                primary: KeyChord(2048  | 41 , 2048  | 512  | 33 ),
-                weight: 100 ,
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyC),
+                weight: KeybindingWeight.EditorContrib,
                 when: CommentContextKeys.activeCursorHasCommentingRange
             }
         });
@@ -265,32 +254,32 @@ registerAction2(class extends Action2 {
         if (!controller) {
             return;
         }
-        const position = args?.range ? ( (new Range(
+        const position = args?.range ? ( new Range(
             args.range.startLineNumber,
             args.range.startLineNumber,
             args.range.endLineNumber,
             args.range.endColumn
-        )))
+        ))
             : (args?.fileComment ? undefined : activeEditor.getSelection());
         const notificationService = accessor.get(INotificationService);
         try {
             await controller.addOrToggleCommentAtLine(position, undefined);
         }
         catch (e) {
-            notificationService.error(( localize(5313, "The cursor must be within a commenting range to add a comment")));
+            notificationService.error(( localize(4858, "The cursor must be within a commenting range to add a comment")));
         }
     }
 });
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "workbench.action.focusCommentOnCurrentLine" ,
+            id: CommentCommandId.FocusCommentOnCurrentLine,
             title: {
-                value: ( localize(5314, "Focus Comment on Current Line")),
+                value: ( localize(4859, "Focus Comment on Current Line")),
                 original: 'Focus Comment on Current Line'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             f1: true,
@@ -322,20 +311,20 @@ registerAction2(class extends Action2 {
             error = true;
         }
         if (error) {
-            notificationService.error(( localize(5315, "The cursor must be on a line with a comment to focus the comment")));
+            notificationService.error(( localize(4860, "The cursor must be on a line with a comment to focus the comment")));
         }
     }
 });
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "workbench.action.collapseAllComments" ,
+            id: CommentCommandId.CollapseAll,
             title: {
-                value: ( localize(5316, "Collapse All Comments")),
+                value: ( localize(4861, "Collapse All Comments")),
                 original: 'Collapse All Comments'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -351,13 +340,13 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "workbench.action.expandAllComments" ,
+            id: CommentCommandId.ExpandAll,
             title: {
-                value: ( localize(5317, "Expand All Comments")),
+                value: ( localize(4862, "Expand All Comments")),
                 original: 'Expand All Comments'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -373,13 +362,13 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: "workbench.action.expandUnresolvedComments" ,
+            id: CommentCommandId.ExpandUnresolved,
             title: {
-                value: ( localize(5318, "Expand Unresolved Comments")),
+                value: ( localize(4863, "Expand Unresolved Comments")),
                 original: 'Expand Unresolved Comments'
             },
             category: {
-                value: ( localize(5307, "Comments")),
+                value: ( localize(4852, "Comments")),
                 original: 'Comments'
             },
             menu: [{
@@ -393,9 +382,9 @@ registerAction2(class extends Action2 {
     }
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: "editor.action.submitComment" ,
-    weight: 100 ,
-    primary: 2048  | 3 ,
+    id: CommentCommandId.Submit,
+    weight: KeybindingWeight.EditorContrib,
+    primary: KeyMod.CtrlCmd | KeyCode.Enter,
     when: ctxCommentEditorFocused,
     handler: (accessor, args) => {
         const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
@@ -405,16 +394,40 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
     }
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
-    id: "workbench.action.hideComment" ,
-    weight: 100 ,
-    primary: 9 ,
-    secondary: [1024  | 9 ],
-    when: ctxCommentEditorFocused,
+    id: CommentCommandId.Hide,
+    weight: KeybindingWeight.EditorContrib,
+    primary: KeyCode.Escape,
+    secondary: [KeyMod.Shift | KeyCode.Escape],
+    when: ( ContextKeyExpr.or(ctxCommentEditorFocused, CommentContextKeys.commentFocused)),
     handler: (accessor, args) => {
         const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
         if (activeCodeEditor instanceof SimpleCommentEditor) {
             activeCodeEditor.getParentThread().collapse();
         }
+        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 {
+                    controller.collapseAndFocusRange(activeComment.thread.threadId);
+                }
+            }
+            catch (e) {
+                error = true;
+            }
+            if (error) {
+                notificationService.error(( localize(4860, "The cursor must be on a line with a comment to focus the comment")));
+            }
+        }
     }
 });
 function getActiveEditor(accessor) {

package/vscode/src/vs/workbench/contrib/comments/browser/commentsInputContentProvider.d.ts

@@ -0,0 +1,15 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ICodeEditorService } from "vscode/vscode/vs/editor/browser/services/codeEditorService";
+import { IEditorContribution } from "vscode/vscode/vs/editor/common/editorCommon";
+import { ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { ITextModel } from "vscode/vscode/vs/editor/common/model";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+import { ITextModelContentProvider, ITextModelService } from "vscode/vscode/vs/editor/common/services/resolverService";
+export declare class CommentsInputContentProvider extends Disposable implements ITextModelContentProvider, IEditorContribution {
+    private readonly _modelService;
+    private readonly _languageService;
+    static readonly ID = "comments.input.contentProvider";
+    constructor(textModelService: ITextModelService, codeEditorService: ICodeEditorService, _modelService: IModelService, _languageService: ILanguageService);
+    provideTextContent(resource: URI): Promise<ITextModel | null>;
+}

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

@@ -1,11 +1,13 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 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';
-import { applyTextEditorOptions } from 'vscode/vscode/vs/workbench/common/editor/editorOptions';
+import { applyTextEditorOptions } from '@codingame/monaco-vscode-219d9a5f-b446-507b-a188-1178a0867c75-common/vscode/vs/workbench/common/editor/editorOptions';
 import { SimpleCommentEditor } from 'vscode/vscode/vs/workbench/contrib/comments/browser/simpleCommentEditor';
 
 let CommentsInputContentProvider = class CommentsInputContentProvider extends Disposable {
@@ -23,7 +25,7 @@ let CommentsInputContentProvider = class CommentsInputContentProvider extends Di
                 return null;
             }
             if (input.options) {
-                applyTextEditorOptions(input.options, editor, 1 );
+                applyTextEditorOptions(input.options, editor, ScrollType.Immediate);
             }
             return editor;
         }));

package/comments.js

@@ -1,12 +0,0 @@
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service';
-import { CommentService } from './vscode/src/vs/workbench/contrib/comments/browser/commentService.js';
-import './vscode/src/vs/workbench/contrib/comments/browser/comments.contribution.js';
-
-function getServiceOverride() {
-    return {
-        [( ICommentService.toString())]: new SyncDescriptor(CommentService, [], true)
-    };
-}
-
-export { getServiceOverride as default };