@codingame/monaco-vscode-debug-service-override 4.5.1 → 5.0.0

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

@@ -15,10 +15,12 @@ import { MenuId, registerAction2 } from 'vscode/vscode/vs/platform/actions/commo
 import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
 import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService.service';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
 import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
@@ -29,6 +31,7 @@ import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeServi
 import { ViewPane, ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
 import { renderViewTree, AbstractExpressionDataSource, AbstractExpressionsRenderer, renderExpressionValue, renderVariable } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
+import { COPY_VALUE_LABEL, COPY_VALUE_ID, COPY_EVALUATE_PATH_LABEL, COPY_EVALUATE_PATH_ID, ADD_TO_WATCH_LABEL, ADD_TO_WATCH_ID } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugCommands';
 import { LinkDetector } from './linkDetector.js';
 import { CONTEXT_VARIABLES_FOCUSED, CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED, VARIABLES_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
@@ -41,19 +44,20 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
 var VisualizedVariableRenderer_1, VariablesRenderer_1;
+const _moduleId = "vs/workbench/contrib/debug/browser/variablesView";
 const $ = $$1;
 let forgetScopes = true;
 let variableInternalContext;
 let dataBreakpointInfoResponse;
 let VariablesView = class VariablesView extends ViewPane {
-    constructor(options, contextMenuService, debugService, keybindingService, configurationService, instantiationService, viewDescriptorService, contextKeyService, openerService, themeService, telemetryService, menuService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+    constructor(options, contextMenuService, debugService, keybindingService, configurationService, instantiationService, viewDescriptorService, contextKeyService, openerService, themeService, telemetryService, hoverService, menuService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
         this.debugService = debugService;
         this.menuService = menuService;
         this.needsRefresh = false;
-        this.savedViewState = ( new Map());
-        this.autoExpandedScopes = ( new Set());
-        this.updateTreeScheduler = ( new RunOnceScheduler(async () => {
+        this.savedViewState = ( (new Map()));
+        this.autoExpandedScopes = ( (new Set()));
+        this.updateTreeScheduler = ( (new RunOnceScheduler(async () => {
             const stackFrame = this.debugService.getViewModel().focusedStackFrame;
             this.needsRefresh = false;
             const input = this.tree.getInput();
@@ -72,7 +76,7 @@ let VariablesView = class VariablesView extends ViewPane {
                 this.autoExpandedScopes.add(toExpand.getId());
                 await this.tree.expand(toExpand);
             }
-        }, 400));
+        }, 400)));
     }
     renderBody(container) {
         super.renderBody(container);
@@ -80,18 +84,16 @@ let VariablesView = class VariablesView extends ViewPane {
         container.classList.add('debug-variables');
         const treeContainer = renderViewTree(container);
         const linkDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( new VariablesDelegate()), [
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( (new VariablesDelegate())), [
             this.instantiationService.createInstance(VariablesRenderer, linkDetector),
             this.instantiationService.createInstance(VisualizedVariableRenderer, linkDetector),
-            ( new ScopesRenderer()),
-            ( new ScopeErrorRenderer()),
+            ( (new ScopesRenderer())),
+            ( (new ScopeErrorRenderer())),
         ], this.instantiationService.createInstance(VariablesDataSource), {
-            accessibilityProvider: ( new VariablesAccessibilityProvider()),
+            accessibilityProvider: ( (new VariablesAccessibilityProvider())),
             identityProvider: { getId: (element) => element.getId() },
             keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
-            overrideStyles: {
-                listBackground: this.getBackgroundColor()
-            }
+            overrideStyles: this.getLocationBasedColors().listOverrideStyles
         });
         this._register(VisualizedVariableRenderer.rendererOnVisualizationRange(this.debugService.getViewModel(), this.tree));
         this.tree.setInput(this.debugService.getViewModel().focusedStackFrame ?? null);
@@ -180,25 +182,26 @@ let VariablesView = class VariablesView extends ViewPane {
         return openContextMenuForVariableTreeElement(this.contextKeyService, this.menuService, this.contextMenuService, MenuId.DebugVariablesContext, e);
     }
 };
-VariablesView = ( __decorate([
-    ( __param(1, IContextMenuService)),
-    ( __param(2, IDebugService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IViewDescriptorService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, ITelemetryService)),
-    ( __param(11, IMenuService))
-], VariablesView));
+VariablesView = ( (__decorate([
+    ( (__param(1, IContextMenuService))),
+    ( (__param(2, IDebugService))),
+    ( (__param(3, IKeybindingService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IViewDescriptorService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IOpenerService))),
+    ( (__param(9, IThemeService))),
+    ( (__param(10, ITelemetryService))),
+    ( (__param(11, IHoverService))),
+    ( (__param(12, IMenuService)))
+], VariablesView)));
 async function openContextMenuForVariableTreeElement(parentContextKeyService, menuService, contextMenuService, menuId, e) {
     const variable = e.element;
     if (!(variable instanceof Variable) || !variable.value) {
         return;
     }
-    const toDispose = ( new DisposableStore());
+    const toDispose = ( (new DisposableStore()));
     try {
         const contextKeyService = await getContextForVariableMenuWithDataAccess(parentContextKeyService, variable);
         const menu = toDispose.add(menuService.createMenu(menuId, contextKeyService));
@@ -298,7 +301,7 @@ class ScopesRenderer {
     }
     renderTemplate(container) {
         const name = append(container, $('.scope'));
-        const label = ( new HighlightedLabel(name));
+        const label = ( (new HighlightedLabel(name)));
         return { name, label };
     }
     renderElement(element, index, templateData) {
@@ -336,8 +339,8 @@ let VisualizedVariableRenderer = class VisualizedVariableRenderer extends Abstra
             tree.updateChildren(parent, false, false);
         });
     }
-    constructor(linkDetector, debugService, contextViewService, menuService, contextKeyService) {
-        super(debugService, contextViewService);
+    constructor(linkDetector, debugService, contextViewService, hoverService, menuService, contextKeyService) {
+        super(debugService, contextViewService, hoverService);
         this.linkDetector = linkDetector;
         this.menuService = menuService;
         this.contextKeyService = contextKeyService;
@@ -358,20 +361,16 @@ let VisualizedVariableRenderer = class VisualizedVariableRenderer extends Abstra
         renderExpressionValue(viz, data.value, {
             showChanged: false,
             maxValueLength: 1024,
-            showHover: true,
+            hover: data.elementDisposable,
             colorize: true,
             linkDetector: this.linkDetector
-        });
+        }, this.hoverService);
     }
     getInputBoxOptions(expression) {
         const viz = expression;
         return {
             initialValue: expression.value,
-            ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'variableValueAriaLabel',
-                "Type new variable value"
-            )),
+            ariaLabel: ( localizeWithPath(_moduleId, 0, "Type new variable value")),
             validationOptions: {
                 validation: () => viz.errorMessage ? ({ content: viz.errorMessage }) : null
             },
@@ -394,11 +393,7 @@ let VisualizedVariableRenderer = class VisualizedVariableRenderer extends Abstra
         const context = viz.original ? getVariablesContext(viz.original) : undefined;
         createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary, secondary: [] }, 'inline');
         if (viz.original) {
-            const action = ( new Action('debugViz', ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'removeVisualizer',
-                'Remove Visualizer'
-            )), ThemeIcon.asClassName(Codicon.eye), true, () => this.debugService.getViewModel().setVisualizedExpression(viz.original, undefined)));
+            const action = ( (new Action('debugViz', ( localizeWithPath(_moduleId, 1, 'Remove Visualizer')), ThemeIcon.asClassName(Codicon.eye), true, () => this.debugService.getViewModel().setVisualizedExpression(viz.original, undefined))));
             action.checked = true;
             primary.push(action);
             actionBar.domNode.style.display = 'initial';
@@ -408,28 +403,30 @@ let VisualizedVariableRenderer = class VisualizedVariableRenderer extends Abstra
         actionBar.push(primary, { icon: true, label: false });
     }
 };
-VisualizedVariableRenderer = VisualizedVariableRenderer_1 = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, IContextViewService)),
-    ( __param(3, IMenuService)),
-    ( __param(4, IContextKeyService))
-], VisualizedVariableRenderer));
+VisualizedVariableRenderer = VisualizedVariableRenderer_1 = ( (__decorate([
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IContextViewService))),
+    ( (__param(3, IHoverService))),
+    ( (__param(4, IMenuService))),
+    ( (__param(5, IContextKeyService)))
+], VisualizedVariableRenderer)));
 let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRenderer {
     static { VariablesRenderer_1 = this; }
     static { this.ID = 'variable'; }
-    constructor(linkDetector, menuService, contextKeyService, visualization, contextMenuService, debugService, contextViewService) {
-        super(debugService, contextViewService);
+    constructor(linkDetector, menuService, contextKeyService, visualization, contextMenuService, commandService, debugService, contextViewService, hoverService) {
+        super(debugService, contextViewService, hoverService);
         this.linkDetector = linkDetector;
         this.menuService = menuService;
         this.contextKeyService = contextKeyService;
         this.visualization = visualization;
         this.contextMenuService = contextMenuService;
+        this.commandService = commandService;
     }
     get templateId() {
         return VariablesRenderer_1.ID;
     }
     renderExpression(expression, data, highlights) {
-        renderVariable(expression, data, true, highlights, this.linkDetector);
+        renderVariable(data.elementDisposable, this.commandService, this.hoverService, expression, data, true, highlights, this.linkDetector);
     }
     renderElement(node, index, data) {
         super.renderExpressionElement(node.element, node, data);
@@ -438,11 +435,7 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
         const variable = expression;
         return {
             initialValue: expression.value,
-            ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'variableValueAriaLabel',
-                "Type new variable value"
-            )),
+            ariaLabel: ( localizeWithPath(_moduleId, 0, "Type new variable value")),
             validationOptions: {
                 validation: () => variable.errorMessage ? ({ content: variable.errorMessage }) : null
             },
@@ -469,28 +462,24 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
         actionBar.clear();
         actionBar.context = context;
         actionBar.push(primary, { icon: true, label: false });
-        const cts = ( new CancellationTokenSource());
+        const cts = ( (new CancellationTokenSource()));
         data.elementDisposable.add(toDisposable(() => cts.dispose(true)));
         this.visualization.getApplicableFor(expression, cts.token).then(result => {
             data.elementDisposable.add(result);
             const originalExpression = (expression instanceof VisualizedExpression && expression.original) || expression;
-            const actions = ( result.object.map(v => ( new Action(
+            const actions = ( (result.object.map(v => ( (new Action(
                 'debugViz',
                 v.name,
                 v.iconClass || 'debug-viz-icon',
                 undefined,
                 this.useVisualizer(v, originalExpression, cts.token)
-            ))));
+            ))))));
             if (actions.length === 0) ;
             else if (actions.length === 1) {
                 actionBar.push(actions[0], { icon: true, label: false });
             }
             else {
-                actionBar.push(( new Action('debugViz', ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/variablesView',
-                    'useVisualizer',
-                    'Visualize Variable...'
-                )), ThemeIcon.asClassName(Codicon.eye), undefined, () => this.pickVisualizer(actions, originalExpression, data))), { icon: true, label: false });
+                actionBar.push(( (new Action('debugViz', ( localizeWithPath(_moduleId, 2, 'Visualize Variable...')), ThemeIcon.asClassName(Codicon.eye), undefined, () => this.pickVisualizer(actions, originalExpression, data)))), { icon: true, label: false });
             }
         });
     }
@@ -518,39 +507,26 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
         };
     }
 };
-VariablesRenderer = VariablesRenderer_1 = ( __decorate([
-    ( __param(1, IMenuService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IDebugVisualizerService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IDebugService)),
-    ( __param(6, IContextViewService))
-], VariablesRenderer));
+VariablesRenderer = VariablesRenderer_1 = ( (__decorate([
+    ( (__param(1, IMenuService))),
+    ( (__param(2, IContextKeyService))),
+    ( (__param(3, IDebugVisualizerService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, ICommandService))),
+    ( (__param(6, IDebugService))),
+    ( (__param(7, IContextViewService))),
+    ( (__param(8, IHoverService)))
+], VariablesRenderer)));
 class VariablesAccessibilityProvider {
     getWidgetAriaLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/variablesView',
-            'variablesAriaTreeLabel',
-            "Debug Variables"
-        ));
+        return ( localizeWithPath(_moduleId, 3, "Debug Variables"));
     }
     getAriaLabel(element) {
         if (element instanceof Scope) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'variableScopeAriaLabel',
-                "Scope {0}",
-                element.name
-            ));
+            return ( localizeWithPath(_moduleId, 4, "Scope {0}", element.name));
         }
         if (element instanceof Variable) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                { key: 'variableAriaLabel', comment: ['Placeholders are variable name and variable value respectivly. They should not be translated.'] },
-                "{0}, value {1}",
-                element.name,
-                element.value
-            ));
+            return ( localizeWithPath(_moduleId, 5, "{0}, value {1}", element.name, element.value));
         }
         return null;
     }
@@ -563,8 +539,10 @@ CommandsRegistry.registerCommand({
         debugService.getViewModel().setSelectedExpression(variableInternalContext, false);
     }
 });
-const COPY_VALUE_ID = 'workbench.debug.viewlet.action.copyValue';
 CommandsRegistry.registerCommand({
+    metadata: {
+        description: COPY_VALUE_LABEL,
+    },
     id: COPY_VALUE_ID,
     handler: async (accessor, arg, ctx) => {
         const debugService = accessor.get(IDebugService);
@@ -585,18 +563,18 @@ CommandsRegistry.registerCommand({
             return;
         }
         const evalContext = session.capabilities.supportsClipboardContext ? 'clipboard' : elementContext;
-        const toEvaluate = ( elements.map(
+        const toEvaluate = ( (elements.map(
             element => element instanceof Variable ? (element.evaluateName || element.value) : element.name
-        ));
+        )));
         try {
-            const evaluations = await Promise.all(( toEvaluate.map(expr => session.evaluate(expr, stackFrame.frameId, evalContext))));
-            const result = ( coalesce(evaluations).map(evaluation => evaluation.body.result));
+            const evaluations = await Promise.all(( (toEvaluate.map(expr => session.evaluate(expr, stackFrame.frameId, evalContext)))));
+            const result = ( (coalesce(evaluations).map(evaluation => evaluation.body.result)));
             if (result.length) {
                 clipboardService.writeText(result.join('\n'));
             }
         }
         catch (e) {
-            const result = ( elements.map(element => element.value));
+            const result = ( (elements.map(element => element.value)));
             clipboardService.writeText(result.join('\n'));
         }
     }
@@ -651,11 +629,7 @@ CommandsRegistry.registerCommand({
 async function tryInstallHexEditor(extensionsWorkbenchService, notificationService) {
     try {
         await extensionsWorkbenchService.install(HEX_EDITOR_EXTENSION_ID, {
-            justification: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                "viewMemory.prompt",
-                "Inspecting binary data requires this extension."
-            )),
+            justification: ( localizeWithPath(_moduleId, 6, "Inspecting binary data requires this extension.")),
             enable: true
         }, 15 );
         return true;
@@ -695,16 +669,20 @@ CommandsRegistry.registerCommand({
         }
     }
 });
-const COPY_EVALUATE_PATH_ID = 'debug.copyEvaluatePath';
 CommandsRegistry.registerCommand({
+    metadata: {
+        description: COPY_EVALUATE_PATH_LABEL,
+    },
     id: COPY_EVALUATE_PATH_ID,
     handler: async (accessor, context) => {
         const clipboardService = accessor.get(IClipboardService);
         await clipboardService.writeText(context.variable.evaluateName);
     }
 });
-const ADD_TO_WATCH_ID = 'debug.addToWatchExpressions';
 CommandsRegistry.registerCommand({
+    metadata: {
+        description: ADD_TO_WATCH_LABEL,
+    },
     id: ADD_TO_WATCH_ID,
     handler: async (accessor, context) => {
         const debugService = accessor.get(IDebugService);
@@ -716,17 +694,13 @@ registerAction2(class extends ViewAction {
         super({
             id: 'variables.collapse',
             viewId: VARIABLES_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'collapse',
-                "Collapse All"
-            )),
+            title: ( localizeWithPath(_moduleId, 7, "Collapse All")),
             f1: false,
             icon: Codicon.collapseAll,
             menu: {
                 id: MenuId.ViewTitle,
                 group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', VARIABLES_VIEW_ID))
+                when: ( (ContextKeyExpr.equals('view', VARIABLES_VIEW_ID)))
             }
         });
     }
@@ -735,4 +709,4 @@ registerAction2(class extends ViewAction {
     }
 });
 
-export { ADD_TO_WATCH_ID, BREAK_WHEN_VALUE_CHANGES_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID, BREAK_WHEN_VALUE_IS_READ_ID, COPY_EVALUATE_PATH_ID, COPY_VALUE_ID, SET_VARIABLE_ID, VIEW_MEMORY_ID, VariablesRenderer, VariablesView, VisualizedVariableRenderer, openContextMenuForVariableTreeElement };
+export { BREAK_WHEN_VALUE_CHANGES_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID, BREAK_WHEN_VALUE_IS_READ_ID, SET_VARIABLE_ID, VIEW_MEMORY_ID, VariablesRenderer, VariablesView, VisualizedVariableRenderer, openContextMenuForVariableTreeElement };