@codingame/monaco-vscode-comments-service-override 4.4.1 → 4.5.0-improve-code-splitting.1

package/comments.js

@@ -1,5 +1,6 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { ICommentService, CommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
+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() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-comments-service-override",
-  "version": "4.4.1",
+  "version": "4.5.0-improve-code-splitting.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -17,7 +17,15 @@
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js"
+    }
+  },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.4.1"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.5.0-improve-code-splitting.1"
   }
 }

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

@@ -0,0 +1,46 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+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) {
+        this.menuService = menuService;
+    }
+    getCommentThreadTitleActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentThreadTitle, contextKeyService);
+    }
+    getCommentThreadActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentThreadActions, contextKeyService);
+    }
+    getCommentEditorActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentEditorActions, contextKeyService);
+    }
+    getCommentThreadAdditionalActions(contextKeyService) {
+        return this.getMenu(MenuId.CommentThreadAdditionalActions, contextKeyService);
+    }
+    getCommentTitleActions(comment, contextKeyService) {
+        return this.getMenu(MenuId.CommentTitle, contextKeyService);
+    }
+    getCommentActions(comment, contextKeyService) {
+        return this.getMenu(MenuId.CommentActions, contextKeyService);
+    }
+    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;
+    }
+    dispose() {
+    }
+};
+CommentMenus = ( __decorate([
+    ( __param(0, IMenuService))
+], CommentMenus));
+
+export { CommentMenus };

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

@@ -0,0 +1,355 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+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';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+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 'vscode/vscode/vs/workbench/contrib/comments/common/commentsConfiguration';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+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 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsModel';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+
+const CONTINUE_ON_COMMENTS = 'comments.continueOnComments';
+let CommentService = class CommentService extends Disposable {
+    constructor(instantiationService, layoutService, configurationService, contextKeyService, storageService, logService, modelService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.layoutService = layoutService;
+        this.configurationService = configurationService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.modelService = modelService;
+        this._onDidSetDataProvider = this._register(( new Emitter()));
+        this.onDidSetDataProvider = this._onDidSetDataProvider.event;
+        this._onDidDeleteDataProvider = this._register(( new Emitter()));
+        this.onDidDeleteDataProvider = this._onDidDeleteDataProvider.event;
+        this._onDidSetResourceCommentInfos = this._register(( new Emitter()));
+        this.onDidSetResourceCommentInfos = this._onDidSetResourceCommentInfos.event;
+        this._onDidSetAllCommentThreads = this._register(( new Emitter()));
+        this.onDidSetAllCommentThreads = this._onDidSetAllCommentThreads.event;
+        this._onDidUpdateCommentThreads = this._register(( new Emitter()));
+        this.onDidUpdateCommentThreads = this._onDidUpdateCommentThreads.event;
+        this._onDidUpdateNotebookCommentThreads = this._register(( new Emitter()));
+        this.onDidUpdateNotebookCommentThreads = this._onDidUpdateNotebookCommentThreads.event;
+        this._onDidUpdateCommentingRanges = this._register(( new Emitter()));
+        this.onDidUpdateCommentingRanges = this._onDidUpdateCommentingRanges.event;
+        this._onDidChangeActiveEditingCommentThread = this._register(( new Emitter()));
+        this.onDidChangeActiveEditingCommentThread = this._onDidChangeActiveEditingCommentThread.event;
+        this._onDidChangeCurrentCommentThread = this._register(( new Emitter()));
+        this.onDidChangeCurrentCommentThread = this._onDidChangeCurrentCommentThread.event;
+        this._onDidChangeCommentingEnabled = this._register(( new Emitter()));
+        this.onDidChangeCommentingEnabled = this._onDidChangeCommentingEnabled.event;
+        this._onDidChangeActiveCommentingRange = this._register(( new Emitter()));
+        this.onDidChangeActiveCommentingRange = this._onDidChangeActiveCommentingRange.event;
+        this._commentControls = ( new Map());
+        this._commentMenus = ( new Map());
+        this._isCommentingEnabled = true;
+        this._continueOnComments = ( new Map());
+        this._continueOnCommentProviders = ( new Set());
+        this._commentsModel = this._register(( new CommentsModel()));
+        this.commentsModel = this._commentsModel;
+        this._commentingRangeResources = ( new Set());
+        this._commentingRangeResourceHintSchemes = ( new Set());
+        this._handleConfiguration();
+        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);
+        storageListener.add(storageEvent(v => {
+            if (!v.external) {
+                return;
+            }
+            const commentsToRestore = this.storageService.getObject(CONTINUE_ON_COMMENTS, 1 );
+            if (!commentsToRestore) {
+                return;
+            }
+            this.logService.debug(`Comments: URIs of continue on comments from storage ${( commentsToRestore.map(thread => ( thread.uri.toString()))).join(', ')}.`);
+            const changedOwners = this._addContinueOnComments(commentsToRestore, this._continueOnComments);
+            for (const uniqueOwner of changedOwners) {
+                const control = this._commentControls.get(uniqueOwner);
+                if (!control) {
+                    continue;
+                }
+                const evt = {
+                    uniqueOwner: uniqueOwner,
+                    owner: control.owner,
+                    ownerLabel: control.label,
+                    pending: this._continueOnComments.get(uniqueOwner) || [],
+                    added: [],
+                    removed: [],
+                    changed: []
+                };
+                this.updateModelThreads(evt);
+            }
+        }));
+        this._register(storageService.onWillSaveState(() => {
+            const map = ( new Map());
+            for (const provider of this._continueOnCommentProviders) {
+                const pendingComments = provider.provideContinueOnComments();
+                this._addContinueOnComments(pendingComments, map);
+            }
+            this._saveContinueOnComments(map);
+        }));
+        this._register(this.modelService.onModelAdded(model => {
+            if (!( this._commentingRangeResources.has(( model.uri.toString())))) {
+                this.getDocumentComments(model.uri);
+            }
+        }));
+    }
+    _updateResourcesWithCommentingRanges(resource, commentInfos) {
+        for (const comments of commentInfos) {
+            if (comments && (comments.commentingRanges.ranges.length > 0 || comments.threads.length > 0)) {
+                this._commentingRangeResources.add(( resource.toString()));
+            }
+        }
+    }
+    _handleConfiguration() {
+        this._isCommentingEnabled = this._defaultCommentingEnablement;
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('comments.visible')) {
+                this.enableCommenting(this._defaultCommentingEnablement);
+            }
+        }));
+    }
+    _handleZenMode() {
+        let preZenModeValue = this._isCommentingEnabled;
+        this._register(this.layoutService.onDidChangeZenMode(e => {
+            if (e) {
+                preZenModeValue = this._isCommentingEnabled;
+                this.enableCommenting(false);
+            }
+            else {
+                this.enableCommenting(preZenModeValue);
+            }
+        }));
+    }
+    get _defaultCommentingEnablement() {
+        return !!this.configurationService.getValue(COMMENTS_SECTION)?.visible;
+    }
+    get isCommentingEnabled() {
+        return this._isCommentingEnabled;
+    }
+    enableCommenting(enable) {
+        if (enable !== this._isCommentingEnabled) {
+            this._isCommentingEnabled = enable;
+            this._onDidChangeCommentingEnabled.fire(enable);
+        }
+    }
+    setCurrentCommentThread(commentThread) {
+        this._onDidChangeCurrentCommentThread.fire(commentThread);
+    }
+    setActiveEditingCommentThread(commentThread) {
+        this._onDidChangeActiveEditingCommentThread.fire(commentThread);
+    }
+    async setActiveCommentAndThread(uniqueOwner, commentInfo) {
+        const commentController = this._commentControls.get(uniqueOwner);
+        if (!commentController) {
+            return;
+        }
+        if (commentController !== this._lastActiveCommentController) {
+            await this._lastActiveCommentController?.setActiveCommentAndThread(undefined);
+        }
+        this._lastActiveCommentController = commentController;
+        return commentController.setActiveCommentAndThread(commentInfo);
+    }
+    setDocumentComments(resource, commentInfos) {
+        this._onDidSetResourceCommentInfos.fire({ resource, commentInfos });
+    }
+    setModelThreads(ownerId, owner, ownerLabel, commentThreads) {
+        this._commentsModel.setCommentThreads(ownerId, owner, ownerLabel, commentThreads);
+        this._onDidSetAllCommentThreads.fire({ ownerId, ownerLabel, commentThreads });
+    }
+    updateModelThreads(event) {
+        this._commentsModel.updateCommentThreads(event);
+        this._onDidUpdateCommentThreads.fire(event);
+    }
+    setWorkspaceComments(uniqueOwner, commentsByResource) {
+        if (commentsByResource.length) {
+            this._workspaceHasCommenting.set(true);
+        }
+        const control = this._commentControls.get(uniqueOwner);
+        if (control) {
+            this.setModelThreads(uniqueOwner, control.owner, control.label, commentsByResource);
+        }
+    }
+    removeWorkspaceComments(uniqueOwner) {
+        const control = this._commentControls.get(uniqueOwner);
+        if (control) {
+            this.setModelThreads(uniqueOwner, control.owner, control.label, []);
+        }
+    }
+    registerCommentController(uniqueOwner, commentControl) {
+        this._commentControls.set(uniqueOwner, commentControl);
+        this._onDidSetDataProvider.fire();
+    }
+    unregisterCommentController(uniqueOwner) {
+        if (uniqueOwner) {
+            this._commentControls.delete(uniqueOwner);
+        }
+        else {
+            this._commentControls.clear();
+        }
+        this._commentsModel.deleteCommentsByOwner(uniqueOwner);
+        this._onDidDeleteDataProvider.fire(uniqueOwner);
+    }
+    getCommentController(uniqueOwner) {
+        return this._commentControls.get(uniqueOwner);
+    }
+    async createCommentThreadTemplate(uniqueOwner, resource, range) {
+        const commentController = this._commentControls.get(uniqueOwner);
+        if (!commentController) {
+            return;
+        }
+        return commentController.createCommentThreadTemplate(resource, range);
+    }
+    async updateCommentThreadTemplate(uniqueOwner, threadHandle, range) {
+        const commentController = this._commentControls.get(uniqueOwner);
+        if (!commentController) {
+            return;
+        }
+        await commentController.updateCommentThreadTemplate(threadHandle, range);
+    }
+    disposeCommentThread(uniqueOwner, threadId) {
+        const controller = this.getCommentController(uniqueOwner);
+        controller?.deleteCommentThreadMain(threadId);
+    }
+    getCommentMenus(uniqueOwner) {
+        if (this._commentMenus.get(uniqueOwner)) {
+            return this._commentMenus.get(uniqueOwner);
+        }
+        const menu = this.instantiationService.createInstance(CommentMenus);
+        this._commentMenus.set(uniqueOwner, menu);
+        return menu;
+    }
+    updateComments(ownerId, event) {
+        const control = this._commentControls.get(ownerId);
+        if (control) {
+            const evt = Object.assign({}, event, { uniqueOwner: ownerId, ownerLabel: control.label, owner: control.owner });
+            this.updateModelThreads(evt);
+        }
+    }
+    updateNotebookComments(ownerId, event) {
+        const evt = Object.assign({}, event, { uniqueOwner: ownerId });
+        this._onDidUpdateNotebookCommentThreads.fire(evt);
+    }
+    updateCommentingRanges(ownerId, resourceHints) {
+        if (resourceHints?.schemes && resourceHints.schemes.length > 0) {
+            for (const scheme of resourceHints.schemes) {
+                this._commentingRangeResourceHintSchemes.add(scheme);
+            }
+        }
+        this._workspaceHasCommenting.set(true);
+        this._onDidUpdateCommentingRanges.fire({ uniqueOwner: ownerId });
+    }
+    async toggleReaction(uniqueOwner, resource, thread, comment, reaction) {
+        const commentController = this._commentControls.get(uniqueOwner);
+        if (commentController) {
+            return commentController.toggleReaction(resource, thread, comment, reaction, CancellationToken.None);
+        }
+        else {
+            throw new Error('Not supported');
+        }
+    }
+    hasReactionHandler(uniqueOwner) {
+        const commentProvider = this._commentControls.get(uniqueOwner);
+        if (commentProvider) {
+            return !!commentProvider.features.reactionHandler;
+        }
+        return false;
+    }
+    async getDocumentComments(resource) {
+        const commentControlResult = [];
+        for (const control of ( this._commentControls.values())) {
+            commentControlResult.push(control.getDocumentComments(resource, CancellationToken.None)
+                .then(documentComments => {
+                for (const documentCommentThread of documentComments.threads) {
+                    if (documentCommentThread.comments?.length === 0 && documentCommentThread.range) {
+                        this.removeContinueOnComment({ range: documentCommentThread.range, uri: resource, uniqueOwner: documentComments.uniqueOwner });
+                    }
+                }
+                const pendingComments = this._continueOnComments.get(documentComments.uniqueOwner);
+                documentComments.pendingCommentThreads = pendingComments?.filter(pendingComment => ( pendingComment.uri.toString()) === ( resource.toString()));
+                return documentComments;
+            })
+                .catch(_ => {
+                return null;
+            }));
+        }
+        const commentInfos = await Promise.all(commentControlResult);
+        this._updateResourcesWithCommentingRanges(resource, commentInfos);
+        return commentInfos;
+    }
+    async getNotebookComments(resource) {
+        const commentControlResult = [];
+        this._commentControls.forEach(control => {
+            commentControlResult.push(control.getNotebookComments(resource, CancellationToken.None)
+                .catch(_ => {
+                return null;
+            }));
+        });
+        return Promise.all(commentControlResult);
+    }
+    registerContinueOnCommentProvider(provider) {
+        this._continueOnCommentProviders.add(provider);
+        return {
+            dispose: () => {
+                this._continueOnCommentProviders.delete(provider);
+            }
+        };
+    }
+    _saveContinueOnComments(map) {
+        const commentsToSave = [];
+        for (const pendingComments of ( map.values())) {
+            commentsToSave.push(...pendingComments);
+        }
+        this.logService.debug(`Comments: URIs of continue on comments to add to storage ${( commentsToSave.map(thread => ( thread.uri.toString()))).join(', ')}.`);
+        this.storageService.store(CONTINUE_ON_COMMENTS, commentsToSave, 1 , 0 );
+    }
+    removeContinueOnComment(pendingComment) {
+        const pendingComments = this._continueOnComments.get(pendingComment.uniqueOwner);
+        if (pendingComments) {
+            const commentIndex = pendingComments.findIndex(comment => ( comment.uri.toString()) === ( pendingComment.uri.toString()) && Range.equalsRange(comment.range, pendingComment.range) && (pendingComment.isReply === undefined || comment.isReply === pendingComment.isReply));
+            if (commentIndex > -1) {
+                return pendingComments.splice(commentIndex, 1)[0];
+            }
+        }
+        return undefined;
+    }
+    _addContinueOnComments(pendingComments, map) {
+        const changedOwners = ( new Set());
+        for (const pendingComment of pendingComments) {
+            if (!( map.has(pendingComment.uniqueOwner))) {
+                map.set(pendingComment.uniqueOwner, [pendingComment]);
+                changedOwners.add(pendingComment.uniqueOwner);
+            }
+            else {
+                const commentsForOwner = map.get(pendingComment.uniqueOwner);
+                if (commentsForOwner.every(comment => (( comment.uri.toString()) !== ( pendingComment.uri.toString())) || !Range.equalsRange(comment.range, pendingComment.range))) {
+                    commentsForOwner.push(pendingComment);
+                    changedOwners.add(pendingComment.uniqueOwner);
+                }
+            }
+        }
+        return changedOwners;
+    }
+    resourceHasCommentingRanges(resource) {
+        return ( this._commentingRangeResourceHintSchemes.has(resource.scheme)) || ( this._commentingRangeResources.has(( resource.toString())));
+    }
+};
+CommentService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkbenchLayoutService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IModelService))
+], CommentService));
+
+export { CommentService };

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

@@ -2,20 +2,22 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import './commentsEditorContribution.js';
-import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
+import './commentService.js';
+import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service';
 import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 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 { IActivityService, NumberBadge } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { NumberBadge } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+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 { 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';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+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 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsController';
 
 registerAction2(class Collapse extends ViewAction {

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

@@ -6,14 +6,14 @@ import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/cod
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { KeybindingsRegistry } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
-import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
+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';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { 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';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+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';