@codingame/monaco-vscode-comments-service-override 4.1.0 → 4.1.2

package/comments.js

@@ -1,6 +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 'vscode/vscode/vs/workbench/contrib/comments/browser/comments.contribution';
+import './vscode/src/vs/workbench/contrib/comments/browser/comments.contribution.js';
 
 function getServiceOverride() {
     return {

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-comments-service-override",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.2"
   }
 }

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

@@ -0,0 +1,233 @@
+import { __decorate, __param } from '../../../../../../../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 { 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 { NumberBadge, IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+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 { revealCommentThread } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentsController';
+
+registerAction2(class Collapse extends ViewAction {
+    constructor() {
+        super({
+            viewId: COMMENTS_VIEW_ID,
+            id: 'comments.collapse',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'collapseAll',
+                "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)),
+                order: 100
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.collapseAll();
+    }
+});
+registerAction2(class Expand extends ViewAction {
+    constructor() {
+        super({
+            viewId: COMMENTS_VIEW_ID,
+            id: 'comments.expand',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'expandAll',
+                "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))),
+                order: 100
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.expandAll();
+    }
+});
+registerAction2(class Reply extends Action2 {
+    constructor() {
+        super({
+            id: 'comments.reply',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'reply',
+                "Reply"
+            )),
+            icon: Codicon.reply,
+            menu: {
+                id: MenuId.CommentsViewThreadActions,
+                order: 100,
+                when: ( ContextKeyExpr.equals('canReply', true))
+            },
+        });
+    }
+    run(accessor, marshalledCommentThread) {
+        const commentService = accessor.get(ICommentService);
+        const editorService = accessor.get(IEditorService);
+        const uriIdentityService = accessor.get(IUriIdentityService);
+        revealCommentThread(commentService, editorService, uriIdentityService, marshalledCommentThread.thread, marshalledCommentThread.thread.comments[marshalledCommentThread.thread.comments.length - 1], true);
+    }
+});
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: 'comments',
+    order: 20,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/comments/browser/comments.contribution',
+        'commentsConfigurationTitle',
+        "Comments"
+    )),
+    type: 'object',
+    properties: {
+        'comments.openPanel': {
+            enum: ['neverOpen', 'openOnSessionStart', 'openOnSessionStartWithComments'],
+            default: 'openOnSessionStartWithComments',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'openComments',
+                "Controls when the comments panel should open."
+            )),
+            restricted: false,
+            markdownDeprecationMessage: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.openPanel.deprecated',
+                "This setting is deprecated in favor of `comments.openView`."
+            ))
+        },
+        'comments.openView': {
+            enum: ['never', 'file', 'firstFile', 'firstFileUnresolved'],
+            enumDescriptions: [( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.openView.never',
+                "The comments view will never be opened."
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.openView.file',
+                "The comments view will open when a file with comments is active."
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.openView.firstFile',
+                "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."
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.openView.firstFileUnresolved',
+                "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: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.openView',
+                "Controls when the comments view should open."
+            )),
+            restricted: false
+        },
+        'comments.useRelativeTime': {
+            type: 'boolean',
+            default: true,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'useRelativeTime',
+                "Determines if relative time will be used in comment timestamps (ex. '1 day ago')."
+            ))
+        },
+        'comments.visible': {
+            type: 'boolean',
+            default: true,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.visible',
+                "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: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'comments.maxHeight',
+                "Controls whether the comments widget scrolls or expands."
+            ))
+        },
+        'comments.collapseOnResolve': {
+            type: 'boolean',
+            default: true,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/comments.contribution',
+                'collapseOnResolve',
+                "Controls whether the comment thread should collapse when the thread is resolved."
+            ))
+        }
+    }
+});
+let UnresolvedCommentsBadge = class UnresolvedCommentsBadge extends Disposable {
+    constructor(_commentService, activityService) {
+        super();
+        this._commentService = _commentService;
+        this.activityService = activityService;
+        this.activity = this._register(( new MutableDisposable()));
+        this.totalUnresolved = 0;
+        this._register(this._commentService.onDidSetAllCommentThreads(this.onAllCommentsChanged, this));
+        this._register(this._commentService.onDidUpdateCommentThreads(this.onCommentsUpdated, this));
+    }
+    onAllCommentsChanged(e) {
+        let unresolved = 0;
+        for (const thread of e.commentThreads) {
+            if (thread.state === CommentThreadState.Unresolved) {
+                unresolved++;
+            }
+        }
+        this.updateBadge(unresolved);
+    }
+    onCommentsUpdated() {
+        let unresolved = 0;
+        for (const resource of this._commentService.commentsModel.resourceCommentThreads) {
+            for (const thread of resource.commentThreads) {
+                if (thread.threadState === CommentThreadState.Unresolved) {
+                    unresolved++;
+                }
+            }
+        }
+        this.updateBadge(unresolved);
+    }
+    updateBadge(unresolved) {
+        if (unresolved === this.totalUnresolved) {
+            return;
+        }
+        this.totalUnresolved = unresolved;
+        const message = ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/comments.contribution',
+            'totalUnresolvedComments',
+            '{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 );
+
+export { UnresolvedCommentsBadge };

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

@@ -0,0 +1,284 @@
+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 } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+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 { ctxCommentEditorFocused, SimpleCommentEditor } from 'vscode/vscode/vs/workbench/contrib/comments/browser/simpleCommentEditor';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+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 { 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';
+
+registerEditorContribution(ID, CommentController, 1 );
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "editor.action.nextCommentThreadAction" ,
+    handler: async (accessor, args) => {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return Promise.resolve();
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return Promise.resolve();
+        }
+        controller.nextCommentThread();
+    },
+    weight: 100 ,
+    primary: 512  | 67 ,
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "editor.action.previousCommentThreadAction" ,
+    handler: async (accessor, args) => {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return Promise.resolve();
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return Promise.resolve();
+        }
+        controller.previousCommentThread();
+    },
+    weight: 100 ,
+    primary: 1024  | 512  | 67
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "editor.action.nextCommentingRange" ,
+    handler: async (accessor, args) => {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return Promise.resolve();
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return Promise.resolve();
+        }
+        controller.nextCommentingRange();
+    },
+    when: ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, ( ContextKeyExpr.or(EditorContextKeys.focus, CommentContextKeys.commentFocused, ( ContextKeyExpr.and(accessibilityHelpIsShown, ( accessibleViewCurrentProviderId.isEqualTo("comments" )))))))),
+    primary: KeyChord(2048  | 41 , 2048  | 512  | 18 ),
+    weight: 100
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: "editor.action.nextCommentingRange" ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+            'comments.nextCommentingRange',
+            "Go to Next Commenting Range"
+        )),
+        category: 'Comments',
+    },
+    when: CommentContextKeys.activeEditorHasCommentingRange
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "editor.action.previousCommentingRange" ,
+    handler: async (accessor, args) => {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return Promise.resolve();
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return Promise.resolve();
+        }
+        controller.previousCommentingRange();
+    },
+    when: ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, ( ContextKeyExpr.or(EditorContextKeys.focus, CommentContextKeys.commentFocused, ( ContextKeyExpr.and(accessibilityHelpIsShown, ( accessibleViewCurrentProviderId.isEqualTo("comments" )))))))),
+    primary: KeyChord(2048  | 41 , 2048  | 512  | 16 ),
+    weight: 100
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: "editor.action.previousCommentingRange" ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+            'comments.previousCommentingRange',
+            "Go to Previous Commenting Range"
+        )),
+        category: 'Comments',
+    },
+    when: CommentContextKeys.activeEditorHasCommentingRange
+});
+CommandsRegistry.registerCommand({
+    id: "workbench.action.toggleCommenting" ,
+    handler: (accessor) => {
+        const commentService = accessor.get(ICommentService);
+        const enable = commentService.isCommentingEnabled;
+        commentService.enableCommenting(!enable);
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: "workbench.action.toggleCommenting" ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+            'comments.toggleCommenting',
+            "Toggle Editor Commenting"
+        )),
+        category: 'Comments',
+    },
+    when: CommentContextKeys.WorkspaceHasCommenting
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "workbench.action.addComment" ,
+    handler: async (accessor, args) => {
+        const activeEditor = getActiveEditor(accessor);
+        if (!activeEditor) {
+            return Promise.resolve();
+        }
+        const controller = CommentController.get(activeEditor);
+        if (!controller) {
+            return Promise.resolve();
+        }
+        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(( localizeWithPath(
+                'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+                'comments.addCommand.error',
+                "The cursor must be within a commenting range to add a comment"
+            )));
+        }
+    },
+    weight: 100 ,
+    primary: KeyChord(2048  | 41 , 2048  | 512  | 33 ),
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: "workbench.action.addComment" ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+            'comments.addCommand',
+            "Add Comment on Current Selection"
+        )),
+        category: 'Comments'
+    },
+    when: CommentContextKeys.activeCursorHasCommentingRange
+});
+CommandsRegistry.registerCommand({
+    id: "workbench.action.collapseAllComments" ,
+    handler: (accessor) => {
+        return getActiveController(accessor)?.collapseAll();
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: "workbench.action.collapseAllComments" ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+            'comments.collapseAll',
+            "Collapse All Comments"
+        )),
+        category: 'Comments'
+    },
+    when: CommentContextKeys.WorkspaceHasCommenting
+});
+CommandsRegistry.registerCommand({
+    id: "workbench.action.expandAllComments" ,
+    handler: (accessor) => {
+        return getActiveController(accessor)?.expandAll();
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: "workbench.action.expandAllComments" ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+            'comments.expandAll',
+            "Expand All Comments"
+        )),
+        category: 'Comments'
+    },
+    when: CommentContextKeys.WorkspaceHasCommenting
+});
+CommandsRegistry.registerCommand({
+    id: "workbench.action.expandUnresolvedComments" ,
+    handler: (accessor) => {
+        return getActiveController(accessor)?.expandUnresolved();
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: "workbench.action.expandUnresolvedComments" ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/comments/browser/commentsEditorContribution',
+            'comments.expandUnresolved',
+            "Expand Unresolved Comments"
+        )),
+        category: 'Comments'
+    },
+    when: CommentContextKeys.WorkspaceHasCommenting
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "editor.action.submitComment" ,
+    weight: 100 ,
+    primary: 2048  | 3 ,
+    when: ctxCommentEditorFocused,
+    handler: (accessor, args) => {
+        const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+        if (activeCodeEditor instanceof SimpleCommentEditor) {
+            activeCodeEditor.getParentThread().submitComment();
+        }
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: "workbench.action.hideComment" ,
+    weight: 100 ,
+    primary: 9 ,
+    secondary: [1024  | 9 ],
+    when: ctxCommentEditorFocused,
+    handler: (accessor, args) => {
+        const activeCodeEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+        if (activeCodeEditor instanceof SimpleCommentEditor) {
+            activeCodeEditor.getParentThread().collapse();
+        }
+    }
+});
+function getActiveEditor(accessor) {
+    let activeTextEditorControl = accessor.get(IEditorService).activeTextEditorControl;
+    if (isDiffEditor(activeTextEditorControl)) {
+        if (activeTextEditorControl.getOriginalEditor().hasTextFocus()) {
+            activeTextEditorControl = activeTextEditorControl.getOriginalEditor();
+        }
+        else {
+            activeTextEditorControl = activeTextEditorControl.getModifiedEditor();
+        }
+    }
+    if (!isCodeEditor(activeTextEditorControl) || !activeTextEditorControl.hasModel()) {
+        return null;
+    }
+    return activeTextEditorControl;
+}
+function getActiveController(accessor) {
+    const activeEditor = getActiveEditor(accessor);
+    if (!activeEditor) {
+        return undefined;
+    }
+    const controller = CommentController.get(activeEditor);
+    if (!controller) {
+        return undefined;
+    }
+    return controller;
+}
+
+export { getActiveEditor };