@codingame/monaco-vscode-api 8.0.4 → 9.0.2

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

@@ -4,14 +4,21 @@ import { localize } from '../../../../nls.js';
 import { ContextKeyExpr, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { CommentsViewFilterFocusContextKey } from './comments.js';
-import { registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { registerAction2, MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
 import { ViewAction } from '../../../browser/parts/views/viewPane.js';
 import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { COMMENTS_VIEW_ID } from './commentsTreeViewer.js';
 import { FocusedViewContext } from '../../../common/contextkeys.js';
 import { viewFilterSubmenu } from '../../../browser/parts/views/viewFilter.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+var CommentsSortOrder;
+( ((function(CommentsSortOrder) {
+    CommentsSortOrder["ResourceAscending"] = "resourceAscending";
+    CommentsSortOrder["UpdatedAtDescending"] = "updatedAtDescending";
+})(CommentsSortOrder || (CommentsSortOrder = {}))));
 const CONTEXT_KEY_SHOW_RESOLVED = ( (new RawContextKey('commentsView.showResolvedFilter', true)));
 const CONTEXT_KEY_SHOW_UNRESOLVED = ( (new RawContextKey('commentsView.showUnResolvedFilter', true)));
+const CONTEXT_KEY_SORT_BY = ( (new RawContextKey('commentsView.sortBy', CommentsSortOrder.ResourceAscending)));
 class CommentsFilters extends Disposable {
     constructor(options, contextKeyService) {
         super();
@@ -20,8 +27,10 @@ class CommentsFilters extends Disposable {
         this.onDidChange = this._onDidChange.event;
         this._showUnresolved = CONTEXT_KEY_SHOW_UNRESOLVED.bindTo(this.contextKeyService);
         this._showResolved = CONTEXT_KEY_SHOW_RESOLVED.bindTo(this.contextKeyService);
+        this._sortBy = CONTEXT_KEY_SORT_BY.bindTo(this.contextKeyService);
         this._showResolved.set(options.showResolved);
         this._showUnresolved.set(options.showUnresolved);
+        this._sortBy.set(options.sortBy);
     }
     get showUnresolved() {
         return !!this._showUnresolved.get();
@@ -41,12 +50,21 @@ class CommentsFilters extends Disposable {
             this._onDidChange.fire({ showResolved: true });
         }
     }
+    get sortBy() {
+        return this._sortBy.get() ?? CommentsSortOrder.ResourceAscending;
+    }
+    set sortBy(sortBy) {
+        if (this._sortBy.get() !== sortBy) {
+            this._sortBy.set(sortBy);
+            this._onDidChange.fire({ sortBy });
+        }
+    }
 }
 registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsFocusViewFromFilter',
-            title: ( localize(9994, "Focus Comments view")),
+            title: ( localize(10032, "Focus Comments view")),
             keybinding: {
                 when: CommentsViewFilterFocusContextKey,
                 weight: KeybindingWeight.WorkbenchContrib,
@@ -63,7 +81,7 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsClearFilterText',
-            title: ( localize(9995, "Clear filter text")),
+            title: ( localize(10033, "Clear filter text")),
             keybinding: {
                 when: CommentsViewFilterFocusContextKey,
                 weight: KeybindingWeight.WorkbenchContrib,
@@ -80,7 +98,7 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: 'commentsFocusFilter',
-            title: ( localize(9996, "Focus comments filter")),
+            title: ( localize(10034, "Focus comments filter")),
             keybinding: {
                 when: ( (FocusedViewContext.isEqualTo(COMMENTS_VIEW_ID))),
                 weight: KeybindingWeight.WorkbenchContrib,
@@ -97,11 +115,11 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleUnResolvedComments`,
-            title: ( localize(9997, "Show Unresolved")),
-            category: ( localize(9998, "Comments")),
+            title: ( localize(10035, "Show Unresolved")),
+            category: ( localize(10036, "Comments")),
             toggled: {
                 condition: CONTEXT_KEY_SHOW_UNRESOLVED,
-                title: ( localize(9999, "Show Unresolved")),
+                title: ( localize(10037, "Show Unresolved")),
             },
             menu: {
                 id: viewFilterSubmenu,
@@ -120,11 +138,11 @@ registerAction2(class extends ViewAction {
     constructor() {
         super({
             id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleResolvedComments`,
-            title: ( localize(10000, "Show Resolved")),
-            category: ( localize(9998, "Comments")),
+            title: ( localize(10038, "Show Resolved")),
+            category: ( localize(10036, "Comments")),
             toggled: {
                 condition: CONTEXT_KEY_SHOW_RESOLVED,
-                title: ( localize(10001, "Show Resolved")),
+                title: ( localize(10039, "Show Resolved")),
             },
             menu: {
                 id: viewFilterSubmenu,
@@ -139,4 +157,60 @@ registerAction2(class extends ViewAction {
         view.filters.showResolved = !view.filters.showResolved;
     }
 });
-export { CommentsFilters };
+const commentSortSubmenu = ( (new MenuId('submenu.filter.commentSort')));
+MenuRegistry.appendMenuItem(viewFilterSubmenu, {
+    submenu: commentSortSubmenu,
+    title: ( localize(10040, "Sort By")),
+    group: '2_sort',
+    icon: Codicon.history,
+    when: ( (ContextKeyExpr.equals('view', COMMENTS_VIEW_ID))),
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleSortByUpdatedAt`,
+            title: ( localize(10041, "Updated Time")),
+            category: ( localize(10036, "Comments")),
+            icon: Codicon.history,
+            viewId: COMMENTS_VIEW_ID,
+            toggled: {
+                condition: ( (ContextKeyExpr.equals(CONTEXT_KEY_SORT_BY.key, CommentsSortOrder.UpdatedAtDescending))),
+                title: ( localize(10042, "Updated Time")),
+            },
+            menu: {
+                id: commentSortSubmenu,
+                group: 'navigation',
+                order: 1,
+                isHiddenByDefault: false,
+            },
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.sortBy = CommentsSortOrder.UpdatedAtDescending;
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: `workbench.actions.${COMMENTS_VIEW_ID}.toggleSortByResource`,
+            title: ( localize(10043, "Position in File")),
+            category: ( localize(10036, "Comments")),
+            icon: Codicon.history,
+            viewId: COMMENTS_VIEW_ID,
+            toggled: {
+                condition: ( (ContextKeyExpr.equals(CONTEXT_KEY_SORT_BY.key, CommentsSortOrder.ResourceAscending))),
+                title: ( localize(10044, "Position in File")),
+            },
+            menu: {
+                id: commentSortSubmenu,
+                group: 'navigation',
+                order: 0,
+                isHiddenByDefault: false,
+            },
+        });
+    }
+    async runInView(serviceAccessor, view) {
+        view.filters.sortBy = CommentsSortOrder.ResourceAscending;
+    }
+});
+export { CommentsFilters, CommentsSortOrder };

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

@@ -6,7 +6,7 @@ import { ActionViewItem } from '../../../../base/browser/ui/actionbar/actionView
 class ToggleReactionsAction extends Action {
     static { this.ID = 'toolbar.toggle.pickReactions'; }
     constructor(toggleDropdownMenu, title) {
-        super(ToggleReactionsAction.ID, title || ( localize(11548, "Pick Reactions...")), 'toggle-reactions', true);
+        super(ToggleReactionsAction.ID, title || ( localize(11611, "Pick Reactions...")), 'toggle-reactions', true);
         this._menuActions = [];
         this.toggleDropdownMenu = toggleDropdownMenu;
     }
@@ -49,17 +49,17 @@ class ReactionActionViewItem extends ActionViewItem {
     }
     getTooltip() {
         const action = this.action;
-        const toggleMessage = action.enabled ? ( localize(11549, "Toggle reaction, ")) : '';
+        const toggleMessage = action.enabled ? ( localize(11612, "Toggle reaction, ")) : '';
         if (action.count === undefined) {
-            return ( localize(11550, "{0}{1} reaction", toggleMessage, action.label));
+            return ( localize(11613, "{0}{1} reaction", toggleMessage, action.label));
         }
         else if (action.reactors === undefined || action.reactors.length === 0) {
             if (action.count === 1) {
-                return ( localize(11551, "{0}1 reaction with {1}", toggleMessage, action.label));
+                return ( localize(11614, "{0}1 reaction with {1}", toggleMessage, action.label));
             }
             else if (action.count > 1) {
                 return ( localize(
-                    11552,
+                    11615,
                     "{0}{1} reactions with {2}",
                     toggleMessage,
                     action.count,
@@ -70,7 +70,7 @@ class ReactionActionViewItem extends ActionViewItem {
         else {
             if (action.reactors.length <= 10 && action.reactors.length === action.count) {
                 return ( localize(
-                    11553,
+                    11616,
                     "{0}{1} reacted with {2}",
                     toggleMessage,
                     action.reactors.join(', '),
@@ -80,7 +80,7 @@ class ReactionActionViewItem extends ActionViewItem {
             else if (action.count > 1) {
                 const displayedReactors = action.reactors.slice(0, 10);
                 return ( localize(
-                    11554,
+                    11617,
                     "{0}{1} and {2} more reacted with {3}",
                     toggleMessage,
                     displayedReactors.join(', '),

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

@@ -22,12 +22,13 @@ import { clamp } from '../../../../base/common/numbers.js';
 import { CopyPasteController } from '../../../../editor/contrib/dropOrPasteInto/browser/copyPasteController.js';
 import { CodeActionController } from '../../../../editor/contrib/codeAction/browser/codeActionController.js';
 import { DropIntoEditorController } from '../../../../editor/contrib/dropOrPasteInto/browser/dropIntoEditorController.js';
-import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
+import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController.js';
 import { LinkDetector } from '../../../../editor/contrib/links/browser/links.js';
 import { MessageController } from '../../../../editor/contrib/message/browser/messageController.js';
 import { SelectionClipboardContributionID } from '../../codeEditor/browser/selectionClipboard.js';
 import { MenuId } from '../../../../platform/actions/common/actions.js';
-import { HoverController } from '../../../../editor/contrib/hover/browser/hoverController.js';
+import { ContentHoverController } from '../../../../editor/contrib/hover/browser/contentHoverController2.js';
+import { MarginHoverController } from '../../../../editor/contrib/hover/browser/marginHoverController.js';
 const ctxCommentEditorFocused = ( new RawContextKey('commentEditorFocused', false));
 const MIN_EDITOR_HEIGHT = 5 * 18;
 const MAX_EDITOR_HEIGHT = 25 * 18;
@@ -46,7 +47,8 @@ let SimpleCommentEditor = class SimpleCommentEditor extends CodeEditorWidget {
                     DropIntoEditorController.ID,
                     LinkDetector.ID,
                     MessageController.ID,
-                    HoverController.ID,
+                    ContentHoverController.ID,
+                    MarginHoverController.ID,
                     SelectionClipboardContributionID,
                     InlineCompletionsController.ID,
                     CodeActionController.ID,
@@ -115,7 +117,7 @@ SimpleCommentEditor = ( __decorate([
 function calculateEditorHeight(parentEditor, editor, currentHeight) {
     const layoutInfo = editor.getLayoutInfo();
     const lineHeight = editor.getOption(EditorOption.lineHeight);
-    const contentHeight = (editor._getViewModel()?.getLineCount() * lineHeight) ?? editor.getContentHeight();
+    const contentHeight = (editor._getViewModel()?.getLineCount() * lineHeight);
     if ((contentHeight > layoutInfo.height) ||
         (contentHeight < layoutInfo.height && currentHeight > MIN_EDITOR_HEIGHT)) {
         const linesToAdd = Math.ceil((contentHeight - layoutInfo.height) / lineHeight);

package/vscode/src/vs/workbench/contrib/comments/common/commentContextKeys.js

@@ -3,16 +3,16 @@ import { RawContextKey } from '../../../../platform/contextkey/common/contextkey
 var CommentContextKeys;
 ( ((function(CommentContextKeys) {
     CommentContextKeys.activeCursorHasCommentingRange = ( (new RawContextKey('activeCursorHasCommentingRange', false, {
-        description: ( localize(5301, "Whether the position at the active cursor has a commenting range")),
+        description: ( localize(5281, "Whether the position at the active cursor has a commenting range")),
         type: 'boolean'
     })));
     CommentContextKeys.activeEditorHasCommentingRange = ( (new RawContextKey('activeEditorHasCommentingRange', false, {
-        description: ( localize(5302, "Whether the active editor has a commenting range")),
+        description: ( localize(5282, "Whether the active editor has a commenting range")),
         type: 'boolean'
     })));
     CommentContextKeys.WorkspaceHasCommenting = ( (new RawContextKey('workspaceHasCommenting', false, {
         description: ( localize(
-         5303,
+         5283,
          "Whether the open workspace has either comments or commenting ranges."
         )),
         type: 'boolean'
@@ -20,16 +20,16 @@ var CommentContextKeys;
     CommentContextKeys.commentThreadIsEmpty = ( (new RawContextKey(
      'commentThreadIsEmpty',
      false,
-     { type: 'boolean', description: ( localize(5304, "Set when the comment thread has no comments")) }
+     { type: 'boolean', description: ( localize(5284, "Set when the comment thread has no comments")) }
     )));
-    CommentContextKeys.commentIsEmpty = ( (new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localize(5305, "Set when the comment has no input")) })));
-    CommentContextKeys.commentContext = ( (new RawContextKey('comment', undefined, { type: 'string', description: ( localize(5306, "The context value of the comment")) })));
-    CommentContextKeys.commentThreadContext = ( (new RawContextKey('commentThread', undefined, { type: 'string', description: ( localize(5307, "The context value of the comment thread")) })));
+    CommentContextKeys.commentIsEmpty = ( (new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localize(5285, "Set when the comment has no input")) })));
+    CommentContextKeys.commentContext = ( (new RawContextKey('comment', undefined, { type: 'string', description: ( localize(5286, "The context value of the comment")) })));
+    CommentContextKeys.commentThreadContext = ( (new RawContextKey('commentThread', undefined, { type: 'string', description: ( localize(5287, "The context value of the comment thread")) })));
     CommentContextKeys.commentControllerContext = ( (new RawContextKey(
      'commentController',
      undefined,
-     { type: 'string', description: ( localize(5308, "The comment controller id associated with a comment thread")) }
+     { type: 'string', description: ( localize(5288, "The comment controller id associated with a comment thread")) }
     )));
-    CommentContextKeys.commentFocused = ( (new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localize(5309, "Set when the comment is focused")) })));
+    CommentContextKeys.commentFocused = ( (new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localize(5289, "Set when the comment is focused")) })));
 })(CommentContextKeys || (CommentContextKeys = {}))));
 export { CommentContextKeys };

package/vscode/src/vs/workbench/contrib/comments/common/commentModel.js

@@ -18,6 +18,20 @@ class CommentNode {
     hasReply() {
         return this.replies && this.replies.length !== 0;
     }
+    get lastUpdatedAt() {
+        if (this._lastUpdatedAt === undefined) {
+            let updatedAt = this.comment.timestamp || '';
+            if (this.replies.length) {
+                const reply = this.replies[this.replies.length - 1];
+                const replyUpdatedAt = reply.lastUpdatedAt;
+                if (replyUpdatedAt > updatedAt) {
+                    updatedAt = replyUpdatedAt;
+                }
+            }
+            this._lastUpdatedAt = updatedAt;
+        }
+        return this._lastUpdatedAt;
+    }
 }
 class ResourceWithCommentThreads {
     constructor(uniqueOwner, owner, resource, commentThreads) {
@@ -38,5 +52,21 @@ class ResourceWithCommentThreads {
         commentNodes[0].isRoot = true;
         return commentNodes[0];
     }
+    get lastUpdatedAt() {
+        if (this._lastUpdatedAt === undefined) {
+            let updatedAt = '';
+            if (!this.commentThreads.length) {
+                return updatedAt;
+            }
+            for (const thread of this.commentThreads) {
+                const threadUpdatedAt = thread.lastUpdatedAt;
+                if (threadUpdatedAt && threadUpdatedAt > updatedAt) {
+                    updatedAt = threadUpdatedAt;
+                }
+            }
+            this._lastUpdatedAt = updatedAt;
+        }
+        return this._lastUpdatedAt;
+    }
 }
 export { CommentNode, ResourceWithCommentThreads };

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInput.js

@@ -304,12 +304,12 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
     claim(claimant, targetWindow, scopedContextKeyService) {
         if (this.doCanMove(targetWindow.vscodeWindowId) !== true) {
             throw createEditorOpenError(localize(
-                9516,
+                9534,
                 "Unable to open the editor in this window, it contains modifications that can only be saved in the original window."
             ), [
                 toAction({
                     id: 'openInOriginalWindow',
-                    label: localize(9517, "Open in Original Window"),
+                    label: localize(9535, "Open in Original Window"),
                     run: async () => {
                         const originalPart = this.editorGroupsService.getPart(this.layoutService.getContainer(getWindow(this.webview.container).window));
                         const currentPart = this.editorGroupsService.getPart(this.layoutService.getContainer(targetWindow.window));
@@ -335,7 +335,7 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
             const sourceWindowId = getWindow(this.webview.container).vscodeWindowId;
             if (sourceWindowId !== targetWindowId) {
                 return ( localize(
-                    9518,
+                    9536,
                     "Unable to move '{0}': The editor contains changes that can only be saved in its current window.",
                     this.getName()
                 ));

package/vscode/src/vs/workbench/contrib/debug/browser/baseDebugView.js

@@ -16,6 +16,7 @@ import { IContextViewService } from '../../../../platform/contextview/browser/co
 import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 import { defaultInputBoxStyles } from '../../../../platform/theme/browser/defaultStyles.js';
 import { COPY_VALUE_ID, COPY_EVALUATE_PATH_ID } from './debugCommands.js';
+import { DebugLinkHoverBehavior } from './linkDetector.js';
 import { IDebugService } from '../common/debug.service.js';
 import { Expression, Variable, ExpressionContainer } from '../common/debugModel.js';
 import { IDebugVisualizerService } from '../common/debugVisualizers.service.js';
@@ -30,7 +31,7 @@ function renderViewTree(container) {
     container.appendChild(treeContainer);
     return treeContainer;
 }
-function renderExpressionValue(expressionOrValue, container, options, hoverService) {
+function renderExpressionValue(store, expressionOrValue, container, options, hoverService) {
     let value = typeof expressionOrValue === 'string' ? expressionOrValue : expressionOrValue.value;
     container.className = 'value';
     if (value === null || ((expressionOrValue instanceof Expression || expressionOrValue instanceof Variable || expressionOrValue instanceof ReplEvaluationResult) && !expressionOrValue.available)) {
@@ -65,16 +66,21 @@ function renderExpressionValue(expressionOrValue, container, options, hoverServi
     if (!value) {
         value = '';
     }
-    if (options.linkDetector) {
+    const session = (expressionOrValue instanceof ExpressionContainer) ? expressionOrValue.getSession() : undefined;
+    const hoverBehavior = options.hover === false ? { type: DebugLinkHoverBehavior.Rich, store } : { type: DebugLinkHoverBehavior.None };
+    if (expressionOrValue instanceof ExpressionContainer && expressionOrValue.valueLocationReference !== undefined && session && options.linkDetector) {
         container.textContent = '';
-        const session = (expressionOrValue instanceof ExpressionContainer) ? expressionOrValue.getSession() : undefined;
-        container.appendChild(options.linkDetector.linkify(value, false, session ? session.root : undefined, true));
+        container.appendChild(options.linkDetector.linkifyLocation(value, expressionOrValue.valueLocationReference, session, hoverBehavior));
+    }
+    else if (options.linkDetector) {
+        container.textContent = '';
+        container.appendChild(options.linkDetector.linkify(value, false, session ? session.root : undefined, true, hoverBehavior));
     }
     else {
         container.textContent = value;
     }
-    if (options.hover) {
-        const { store, commands, commandService } = options.hover instanceof DisposableStore ? { store: options.hover, commands: [], commandService: undefined } : options.hover;
+    if (options.hover !== false) {
+        const { commands = [], commandService } = options.hover || {};
         store.add(hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), container, () => {
             const container = $$1('div');
             const markdownHoverElement = $$1('div.hover-row');
@@ -122,10 +128,10 @@ function renderVariable(store, commandService, hoverService, variable, data, sho
     if (variable.evaluateName) {
         commands.push({ id: COPY_EVALUATE_PATH_ID, args: [{ variable }] });
     }
-    renderExpressionValue(variable, data.value, {
+    renderExpressionValue(store, variable, data.value, {
         showChanged,
         maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
-        hover: { store, commands, commandService },
+        hover: { commands, commandService },
         colorize: true,
         linkDetector
     }, hoverService);
@@ -170,7 +176,7 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         const name = append(expression, $('span.name'));
         const lazyButton = append(expression, $('span.lazy-button'));
         lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
-        templateDisposable.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localize(10237, "Click to expand"))));
+        templateDisposable.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localize(10281, "Click to expand"))));
         const type = append(expression, $('span.type'));
         const value = append(expression, $('span.value'));
         const label = templateDisposable.add(( (new HighlightedLabel(name))));