@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -18,6 +18,15 @@ import { CommentContextKeys } from '../common/commentContextKeys.js';
 import { ILanguageConfigurationService } from '../../../../editor/common/languages/languageConfigurationRegistry.js';
 import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.js';
 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 { 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';
 const ctxCommentEditorFocused = ( new RawContextKey('commentEditorFocused', false));
 const MIN_EDITOR_HEIGHT = 5 * 18;
 const MAX_EDITOR_HEIGHT = 25 * 18;
@@ -30,8 +39,19 @@ let SimpleCommentEditor = class SimpleCommentEditor extends CodeEditorWidget {
                 { id: SuggestController.ID, ctor: SuggestController, instantiation: 0  },
                 { id: SnippetController2.ID, ctor: SnippetController2, instantiation: 4  },
                 { id: TabCompletionController.ID, ctor: TabCompletionController, instantiation: 0  },
-                { id: EditorDictation.ID, ctor: EditorDictation, instantiation: 4  }
-            ]
+                { id: EditorDictation.ID, ctor: EditorDictation, instantiation: 4  },
+                ...EditorExtensionsRegistry.getSomeEditorContributions([
+                    CopyPasteController.ID,
+                    DropIntoEditorController.ID,
+                    LinkDetector.ID,
+                    MessageController.ID,
+                    HoverController.ID,
+                    SelectionClipboardContributionID,
+                    InlineCompletionsController.ID,
+                    CodeActionController.ID,
+                ])
+            ],
+            contextMenuId: MenuId.SimpleEditorContext
         };
         super(domElement, options, codeEditorWidgetOptions, instantiationService, codeEditorService, commandService, scopedContextKeyService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
         this._commentEditorFocused = ctxCommentEditorFocused.bindTo(scopedContextKeyService);
@@ -73,6 +93,7 @@ let SimpleCommentEditor = class SimpleCommentEditor extends CodeEditorWidget {
             minimap: {
                 enabled: false
             },
+            dropIntoEditor: { enabled: true },
             autoClosingBrackets: configurationService.getValue('editor.autoClosingBrackets'),
             quickSuggestions: false,
             accessibilitySupport: configurationService.getValue('editor.accessibilitySupport'),

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

@@ -1,18 +1,17 @@
 import { append, $ } from '../../../../base/browser/dom.js';
 import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
-import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
 import { fromNow } from '../../../../base/common/date.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { language } from '../../../../base/common/platform.js';
 import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
 class TimestampWidget extends Disposable {
-    constructor(configurationService, container, timeStamp) {
+    constructor(configurationService, hoverService, container, timeStamp) {
         super();
         this.configurationService = configurationService;
         this._date = append(container, $('span.timestamp'));
         this._date.style.display = 'none';
         this._useRelativeTime = this.useRelativeTimeSetting;
-        this.hover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), this._date, ''));
+        this.hover = this._register(hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), this._date, ''));
         this.setTimestamp(timeStamp);
     }
     get useRelativeTimeSetting() {

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

@@ -1,68 +1,41 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+const _moduleId = "vs/workbench/contrib/comments/common/commentContextKeys";
 var CommentContextKeys;
-( (function(CommentContextKeys) {
-    CommentContextKeys.activeCursorHasCommentingRange = ( new RawContextKey('activeCursorHasCommentingRange', false, {
+( ((function(CommentContextKeys) {
+    CommentContextKeys.activeCursorHasCommentingRange = ( (new RawContextKey('activeCursorHasCommentingRange', false, {
         description: ( localizeWithPath(
-         'vs/workbench/contrib/comments/common/commentContextKeys',
-         'hasCommentingRange',
+         _moduleId,
+         0,
          "Whether the position at the active cursor has a commenting range"
         )),
         type: 'boolean'
-    }));
-    CommentContextKeys.activeEditorHasCommentingRange = ( new RawContextKey('activeEditorHasCommentingRange', false, {
-        description: ( localizeWithPath(
-         'vs/workbench/contrib/comments/common/commentContextKeys',
-         'editorHasCommentingRange',
-         "Whether the active editor has a commenting range"
-        )),
+    })));
+    CommentContextKeys.activeEditorHasCommentingRange = ( (new RawContextKey('activeEditorHasCommentingRange', false, {
+        description: ( localizeWithPath(_moduleId, 1, "Whether the active editor has a commenting range")),
         type: 'boolean'
-    }));
-    CommentContextKeys.WorkspaceHasCommenting = ( new RawContextKey('workspaceHasCommenting', false, {
+    })));
+    CommentContextKeys.WorkspaceHasCommenting = ( (new RawContextKey('workspaceHasCommenting', false, {
         description: ( localizeWithPath(
-         'vs/workbench/contrib/comments/common/commentContextKeys',
-         'hasCommentingProvider',
+         _moduleId,
+         2,
          "Whether the open workspace has either comments or commenting ranges."
         )),
         type: 'boolean'
-    }));
-    CommentContextKeys.commentThreadIsEmpty = ( new RawContextKey(
+    })));
+    CommentContextKeys.commentThreadIsEmpty = ( (new RawContextKey(
      'commentThreadIsEmpty',
      false,
-     { type: 'boolean', description: ( localizeWithPath(
-      'vs/workbench/contrib/comments/common/commentContextKeys',
-      'commentThreadIsEmpty',
-      "Set when the comment thread has no comments"
-     )) }
-    ));
-    CommentContextKeys.commentIsEmpty = ( new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'commentIsEmpty',
-     "Set when the comment has no input"
-    )) }));
-    CommentContextKeys.commentContext = ( new RawContextKey('comment', undefined, { type: 'string', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'comment',
-     "The context value of the comment"
-    )) }));
-    CommentContextKeys.commentThreadContext = ( new RawContextKey('commentThread', undefined, { type: 'string', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'commentThread',
-     "The context value of the comment thread"
-    )) }));
-    CommentContextKeys.commentControllerContext = ( new RawContextKey(
+     { type: 'boolean', description: ( localizeWithPath(_moduleId, 3, "Set when the comment thread has no comments")) }
+    )));
+    CommentContextKeys.commentIsEmpty = ( (new RawContextKey('commentIsEmpty', false, { type: 'boolean', description: ( localizeWithPath(_moduleId, 4, "Set when the comment has no input")) })));
+    CommentContextKeys.commentContext = ( (new RawContextKey('comment', undefined, { type: 'string', description: ( localizeWithPath(_moduleId, 5, "The context value of the comment")) })));
+    CommentContextKeys.commentThreadContext = ( (new RawContextKey('commentThread', undefined, { type: 'string', description: ( localizeWithPath(_moduleId, 6, "The context value of the comment thread")) })));
+    CommentContextKeys.commentControllerContext = ( (new RawContextKey(
      'commentController',
      undefined,
-     { type: 'string', description: ( localizeWithPath(
-      'vs/workbench/contrib/comments/common/commentContextKeys',
-      'commentController',
-      "The comment controller id associated with a comment thread"
-     )) }
-    ));
-    CommentContextKeys.commentFocused = ( new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localizeWithPath(
-     'vs/workbench/contrib/comments/common/commentContextKeys',
-     'commentFocused',
-     "Set when the comment is focused"
-    )) }));
-})(CommentContextKeys || (CommentContextKeys = {})));
+     { type: 'string', description: ( localizeWithPath(_moduleId, 7, "The comment controller id associated with a comment thread")) }
+    )));
+    CommentContextKeys.commentFocused = ( (new RawContextKey('commentFocused', false, { type: 'boolean', description: ( localizeWithPath(_moduleId, 8, "Set when the comment is focused")) })));
+})(CommentContextKeys || (CommentContextKeys = {}))));
 export { CommentContextKeys };

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

@@ -23,6 +23,7 @@ import { IFilesConfigurationService } from '../../../services/filesConfiguration
 import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
 import { IUntitledTextEditorService } from '../../../services/untitled/common/untitledTextEditorService.service.js';
 var CustomEditorInput_1;
+const _moduleId = "vs/workbench/contrib/customEditor/browser/customEditorInput";
 let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEditorInput {
     static { CustomEditorInput_1 = this; }
     static create(instantiationService, resource, viewType, group, options) {
@@ -303,10 +304,14 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
     }
     claim(claimant, targetWindow, scopedContextKeyService) {
         if (this.doCanMove(targetWindow.vscodeWindowId) !== true) {
-            throw createEditorOpenError(localizeWithPath('vs/workbench/contrib/customEditor/browser/customEditorInput', 'editorUnsupportedInWindow', "Unable to open the editor in this window, it contains modifications that can only be saved in the original window."), [
+            throw createEditorOpenError(localizeWithPath(
+                _moduleId,
+                0,
+                "Unable to open the editor in this window, it contains modifications that can only be saved in the original window."
+            ), [
                 toAction({
                     id: 'openInOriginalWindow',
-                    label: localizeWithPath('vs/workbench/contrib/customEditor/browser/customEditorInput', 'reopenInOriginalWindow', "Open in Original Window"),
+                    label: localizeWithPath(_moduleId, 1, "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));
@@ -332,8 +337,8 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
             const sourceWindowId = getWindow(this.webview.container).vscodeWindowId;
             if (sourceWindowId !== targetWindowId) {
                 return ( localizeWithPath(
-                    'vs/workbench/contrib/customEditor/browser/customEditorInput',
-                    'editorCannotMove',
+                    _moduleId,
+                    2,
                     "Unable to move '{0}': The editor contains changes that can only be saved in its current window.",
                     this.getName()
                 ));
@@ -342,17 +347,17 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
         return true;
     }
 };
-CustomEditorInput = CustomEditorInput_1 = ( __decorate([
-    ( __param(3, IWebviewWorkbenchService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, ICustomEditorService)),
-    ( __param(7, IFileDialogService)),
-    ( __param(8, IUndoRedoService)),
-    ( __param(9, IFileService)),
-    ( __param(10, IFilesConfigurationService)),
-    ( __param(11, IEditorGroupsService)),
-    ( __param(12, IWorkbenchLayoutService)),
-    ( __param(13, ICustomEditorLabelService))
-], CustomEditorInput));
+CustomEditorInput = CustomEditorInput_1 = ( (__decorate([
+    ( (__param(3, IWebviewWorkbenchService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, ILabelService))),
+    ( (__param(6, ICustomEditorService))),
+    ( (__param(7, IFileDialogService))),
+    ( (__param(8, IUndoRedoService))),
+    ( (__param(9, IFileService))),
+    ( (__param(10, IFilesConfigurationService))),
+    ( (__param(11, IEditorGroupsService))),
+    ( (__param(12, IWorkbenchLayoutService))),
+    ( (__param(13, ICustomEditorLabelService)))
+], CustomEditorInput)));
 export { CustomEditorInput };

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

@@ -1,9 +1,8 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { append, addDisposableListener, EventType, clearNode, addStandardDisposableListener, $ as $$1 } from '../../../../base/browser/dom.js';
+import { $ as $$1, append, addDisposableListener, EventType, clearNode, addStandardDisposableListener } from '../../../../base/browser/dom.js';
 import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
 import { HighlightedLabel } from '../../../../base/browser/ui/highlightedlabel/highlightedLabel.js';
 import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
-import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
 import { InputBox } from '../../../../base/browser/ui/inputbox/inputBox.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { createMatches } from '../../../../base/common/filters.js';
@@ -11,12 +10,16 @@ import { createSingleCallFunction } from '../../../../base/common/functional.js'
 import { toDisposable, DisposableStore, dispose } from '../../../../base/common/lifecycle.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { localizeWithPath } from '../../../../nls.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
 import { IContextViewService } from '../../../../platform/contextview/browser/contextView.service.js';
+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 { IDebugService } from '../common/debug.service.js';
 import { Expression, Variable, ExpressionContainer } from '../common/debugModel.js';
 import { IDebugVisualizerService } from '../common/debugVisualizers.service.js';
 import { ReplEvaluationResult } from '../common/replModel.js';
+const _moduleId = "vs/workbench/contrib/debug/browser/baseDebugView";
 const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
 const booleanRegex = /^(true|false)$/i;
 const stringRegex = /^(['"]).*\1$/;
@@ -27,7 +30,7 @@ function renderViewTree(container) {
     container.appendChild(treeContainer);
     return treeContainer;
 }
-function renderExpressionValue(expressionOrValue, container, options) {
+function renderExpressionValue(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)) {
@@ -70,11 +73,29 @@ function renderExpressionValue(expressionOrValue, container, options) {
     else {
         container.textContent = value;
     }
-    if (options.showHover) {
-        container.title = value || '';
+    if (options.hover) {
+        const { store, commands, commandService } = options.hover instanceof DisposableStore ? { store: options.hover, commands: [], commandService: undefined } : options.hover;
+        store.add(hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), container, () => {
+            const container = $$1('div');
+            const markdownHoverElement = $$1('div.hover-row');
+            const hoverContentsElement = append(markdownHoverElement, $$1('div.hover-contents'));
+            const hoverContentsPre = append(hoverContentsElement, $$1('pre.debug-var-hover-pre'));
+            hoverContentsPre.textContent = value;
+            container.appendChild(markdownHoverElement);
+            return container;
+        }, {
+            actions: ( (commands.map(({ id, args }) => {
+                const description = CommandsRegistry.getCommand(id)?.metadata?.description;
+                return {
+                    label: typeof description === 'string' ? description : description ? description.value : id,
+                    commandId: id,
+                    run: () => commandService.executeCommand(id, ...args),
+                };
+            })))
+        }));
     }
 }
-function renderVariable(variable, data, showChanged, highlights, linkDetector) {
+function renderVariable(store, commandService, hoverService, variable, data, showChanged, highlights, linkDetector) {
     if (variable.available) {
         let text = variable.name;
         if (variable.value && typeof variable.name === 'string') {
@@ -88,13 +109,19 @@ function renderVariable(variable, data, showChanged, highlights, linkDetector) {
         data.label.set(':');
     }
     data.expression.classList.toggle('lazy', !!variable.presentationHint?.lazy);
+    const commands = [
+        { id: COPY_VALUE_ID, args: [variable, [variable]] }
+    ];
+    if (variable.evaluateName) {
+        commands.push({ id: COPY_EVALUATE_PATH_ID, args: [{ variable }] });
+    }
     renderExpressionValue(variable, data.value, {
         showChanged,
         maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
-        showHover: true,
+        hover: { store, commands, commandService },
         colorize: true,
         linkDetector
-    });
+    }, hoverService);
 }
 let AbstractExpressionDataSource = class AbstractExpressionDataSource {
     constructor(debugService, debugVisualizer) {
@@ -104,7 +131,7 @@ let AbstractExpressionDataSource = class AbstractExpressionDataSource {
     async getChildren(element) {
         const vm = this.debugService.getViewModel();
         const children = await this.doGetChildren(element);
-        return Promise.all(( children.map(async (r) => {
+        return Promise.all(( (children.map(async (r) => {
             const vizOrTree = vm.getVisualizedExpression(r);
             if (typeof vizOrTree === 'string') {
                 const viz = await this.debugVisualizer.getVisualizedNodeFor(vizOrTree, r);
@@ -117,38 +144,35 @@ let AbstractExpressionDataSource = class AbstractExpressionDataSource {
                 return vizOrTree;
             }
             return r;
-        })));
+        }))));
     }
 };
-AbstractExpressionDataSource = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IDebugVisualizerService))
-], AbstractExpressionDataSource));
+AbstractExpressionDataSource = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IDebugVisualizerService)))
+], AbstractExpressionDataSource)));
 let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
-    constructor(debugService, contextViewService) {
+    constructor(debugService, contextViewService, hoverService) {
         this.debugService = debugService;
         this.contextViewService = contextViewService;
+        this.hoverService = hoverService;
     }
     renderTemplate(container) {
-        const templateDisposable = ( new DisposableStore());
+        const templateDisposable = ( (new DisposableStore()));
         const expression = append(container, $('.expression'));
         const name = append(expression, $('span.name'));
         const lazyButton = append(expression, $('span.lazy-button'));
         lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
-        templateDisposable.add(setupCustomHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/baseDebugView',
-            'debug.lazyButton.tooltip',
-            "Click to expand"
-        ))));
+        templateDisposable.add(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), lazyButton, ( localizeWithPath(_moduleId, 0, "Click to expand"))));
         const value = append(expression, $('span.value'));
-        const label = templateDisposable.add(( new HighlightedLabel(name)));
+        const label = templateDisposable.add(( (new HighlightedLabel(name))));
         const inputBoxContainer = append(expression, $('.inputBoxContainer'));
         let actionBar;
         if (this.renderActionBar) {
             append(expression, $('.span.actionbar-spacer'));
-            actionBar = templateDisposable.add(( new ActionBar(expression)));
+            actionBar = templateDisposable.add(( (new ActionBar(expression))));
         }
-        const template = { expression, name, value, label, inputBoxContainer, actionBar, elementDisposable: ( new DisposableStore()), templateDisposable, lazyButton, currentElement: undefined };
+        const template = { expression, name, value, label, inputBoxContainer, actionBar, elementDisposable: ( (new DisposableStore())), templateDisposable, lazyButton, currentElement: undefined };
         templateDisposable.add(addDisposableListener(lazyButton, EventType.CLICK, () => {
             if (template.currentElement) {
                 this.debugService.getViewModel().evaluateLazyExpression(template.currentElement);
@@ -176,11 +200,11 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         valueElement.style.display = 'none';
         inputBoxContainer.style.display = 'initial';
         clearNode(inputBoxContainer);
-        const inputBox = ( new InputBox(
+        const inputBox = ( (new InputBox(
             inputBoxContainer,
             this.contextViewService,
             { ...options, inputBoxStyles: defaultInputBoxStyles }
-        ));
+        )));
         inputBox.value = options.initialValue;
         inputBox.focus();
         inputBox.select();
@@ -226,8 +250,9 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         templateData.templateDisposable.dispose();
     }
 };
-AbstractExpressionsRenderer = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IContextViewService))
-], AbstractExpressionsRenderer));
+AbstractExpressionsRenderer = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IContextViewService))),
+    ( (__param(2, IHoverService)))
+], AbstractExpressionsRenderer)));
 export { AbstractExpressionDataSource, AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree };