@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

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

@@ -1,24 +1,185 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
 import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { timeout, RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
 import { registerAction2, MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
 import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
 import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { ViewAction } from '../../../browser/parts/views/viewPane.js';
-import { AbstractExpressionsRenderer, renderVariable } from './baseDebugView.js';
-import { IDebugService, VARIABLES_VIEW_ID, CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT, CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT, CONTEXT_CAN_VIEW_MEMORY, CONTEXT_VARIABLE_IS_READONLY } from '../common/debug.js';
-import { getUriForDebugMemory, Variable, Expression } from '../common/debugModel.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ViewAction, ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { renderViewTree, AbstractExpressionsRenderer, renderVariable } from './baseDebugView.js';
+import { LinkDetector } from './linkDetector.js';
+import { IDebugService, VARIABLES_VIEW_ID, CONTEXT_VARIABLES_FOCUSED, CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT, CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT, CONTEXT_CAN_VIEW_MEMORY, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED } from '../common/debug.js';
+import { getUriForDebugMemory, Variable, Expression, ErrorScope, Scope, StackFrame } from '../common/debugModel.js';
 import { IEditorService, SIDE_GROUP } from '../../../services/editor/common/editorService.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+const $ = dom.$;
+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);
+        this.debugService = debugService;
+        this.menuService = menuService;
+        this.needsRefresh = false;
+        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();
+            if (input) {
+                this.savedViewState.set(input.getId(), this.tree.getViewState());
+            }
+            if (!stackFrame) {
+                await this.tree.setInput(null);
+                return;
+            }
+            const viewState = this.savedViewState.get(stackFrame.getId());
+            await this.tree.setInput(stackFrame, viewState);
+            const scopes = await stackFrame.getScopes();
+            const toExpand = scopes.find(s => !s.expensive);
+            if (toExpand && this.tree.hasNode(toExpand)) {
+                this.autoExpandedScopes.add(toExpand.getId());
+                await this.tree.expand(toExpand);
+            }
+        }, 400));
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.element.classList.add('debug-pane');
+        container.classList.add('debug-variables');
+        const treeContainer = renderViewTree(container);
+        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( new VariablesDelegate()), [this.instantiationService.createInstance(VariablesRenderer, linkeDetector), ( new ScopesRenderer()), ( new ScopeErrorRenderer())], ( new VariablesDataSource()), {
+            accessibilityProvider: ( new VariablesAccessibilityProvider()),
+            identityProvider: { getId: (element) => element.getId() },
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            }
+        });
+        this.tree.setInput(withUndefinedAsNull(this.debugService.getViewModel().focusedStackFrame));
+        CONTEXT_VARIABLES_FOCUSED.bindTo(this.tree.contextKeyService);
+        this._register(this.debugService.getViewModel().onDidFocusStackFrame(sf => {
+            if (!this.isBodyVisible()) {
+                this.needsRefresh = true;
+                return;
+            }
+            const timeout = sf.explicit ? 0 : undefined;
+            this.updateTreeScheduler.schedule(timeout);
+        }));
+        this._register(this.debugService.getViewModel().onWillUpdateViews(() => {
+            const stackFrame = this.debugService.getViewModel().focusedStackFrame;
+            if (stackFrame && forgetScopes) {
+                stackFrame.forgetScopes();
+            }
+            forgetScopes = true;
+            this.tree.updateChildren();
+        }));
+        this._register(this.tree.onMouseDblClick(e => this.onMouseDblClick(e)));
+        this._register(this.tree.onContextMenu(async (e) => await this.onContextMenu(e)));
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible && this.needsRefresh) {
+                this.updateTreeScheduler.schedule();
+            }
+        }));
+        let horizontalScrolling;
+        this._register(this.debugService.getViewModel().onDidSelectExpression(e => {
+            const variable = e?.expression;
+            if (variable instanceof Variable && !e?.settingWatch) {
+                horizontalScrolling = this.tree.options.horizontalScrolling;
+                if (horizontalScrolling) {
+                    this.tree.updateOptions({ horizontalScrolling: false });
+                }
+                this.tree.rerender(variable);
+            }
+            else if (!e && horizontalScrolling !== undefined) {
+                this.tree.updateOptions({ horizontalScrolling: horizontalScrolling });
+                horizontalScrolling = undefined;
+            }
+        }));
+        this._register(this.debugService.getViewModel().onDidEvaluateLazyExpression(async (e) => {
+            if (e instanceof Variable && this.tree.hasNode(e)) {
+                await this.tree.updateChildren(e, false, true);
+                await this.tree.expand(e);
+            }
+        }));
+        this._register(this.debugService.onDidEndSession(() => {
+            this.savedViewState.clear();
+            this.autoExpandedScopes.clear();
+        }));
+    }
+    layoutBody(width, height) {
+        super.layoutBody(height, width);
+        this.tree.layout(width, height);
+    }
+    focus() {
+        this.tree.domFocus();
+    }
+    collapseAll() {
+        this.tree.collapseAll();
+    }
+    onMouseDblClick(e) {
+        const session = this.debugService.getViewModel().focusedSession;
+        if (session && e.element instanceof Variable && session.capabilities.supportsSetVariable && !e.element.presentationHint?.attributes?.includes('readOnly') && !e.element.presentationHint?.lazy) {
+            this.debugService.getViewModel().setSelectedExpression(e.element, false);
+        }
+    }
+    async onContextMenu(e) {
+        const variable = e.element;
+        if (!(variable instanceof Variable) || !variable.value) {
+            return;
+        }
+        const toDispose = ( new DisposableStore());
+        try {
+            const contextKeyService = await getContextForVariableMenuWithDataAccess(this.contextKeyService, variable);
+            const menu = toDispose.add(this.menuService.createMenu(MenuId.DebugVariablesContext, contextKeyService));
+            const context = getVariablesContext(variable);
+            const secondary = [];
+            createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary: [], secondary }, 'inline');
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => e.anchor,
+                getActions: () => secondary
+            });
+        }
+        finally {
+            toDispose.dispose();
+        }
+    }
+};
+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));
 const getVariablesContext = (variable) => ({
     sessionId: variable.getSession()?.getId(),
     container: variable.parent instanceof Expression
@@ -26,6 +187,35 @@ const getVariablesContext = (variable) => ({
         : variable.parent.toDebugProtocolObject(),
     variable: variable.toDebugProtocolObject()
 });
+async function getContextForVariableMenuWithDataAccess(parentContext, variable) {
+    const session = variable.getSession();
+    if (!session || !session.capabilities.supportsDataBreakpoints) {
+        return getContextForVariableMenu(parentContext, variable);
+    }
+    const contextKeys = [];
+    dataBreakpointInfoResponse = await session.dataBreakpointInfo(variable.name, variable.parent.reference);
+    const dataBreakpointId = dataBreakpointInfoResponse?.dataId;
+    const dataBreakpointAccessTypes = dataBreakpointInfoResponse?.accessTypes;
+    if (!dataBreakpointAccessTypes) {
+        contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED.key, !!dataBreakpointId]);
+    }
+    else {
+        for (const accessType of dataBreakpointAccessTypes) {
+            switch (accessType) {
+                case 'read':
+                    contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED.key, !!dataBreakpointId]);
+                    break;
+                case 'write':
+                    contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED.key, !!dataBreakpointId]);
+                    break;
+                case 'readWrite':
+                    contextKeys.push([CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED.key, !!dataBreakpointId]);
+                    break;
+            }
+        }
+    }
+    return getContextForVariableMenu(parentContext, variable, contextKeys);
+}
 function getContextForVariableMenu(parentContext, variable, additionalContext = []) {
     const session = variable.getSession();
     const contextKeys = [
@@ -38,6 +228,72 @@ function getContextForVariableMenu(parentContext, variable, additionalContext =
     variableInternalContext = variable;
     return parentContext.createOverlay(contextKeys);
 }
+function isStackFrame(obj) {
+    return obj instanceof StackFrame;
+}
+class VariablesDataSource {
+    hasChildren(element) {
+        if (!element) {
+            return false;
+        }
+        if (isStackFrame(element)) {
+            return true;
+        }
+        return element.hasChildren;
+    }
+    getChildren(element) {
+        if (isStackFrame(element)) {
+            return element.getScopes();
+        }
+        return element.getChildren();
+    }
+}
+class VariablesDelegate {
+    getHeight(element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        if (element instanceof ErrorScope) {
+            return ScopeErrorRenderer.ID;
+        }
+        if (element instanceof Scope) {
+            return ScopesRenderer.ID;
+        }
+        return VariablesRenderer.ID;
+    }
+}
+class ScopesRenderer {
+    get templateId() {
+        return ScopesRenderer.ID;
+    }
+    renderTemplate(container) {
+        const name = dom.append(container, $('.scope'));
+        const label = ( new HighlightedLabel(name));
+        return { name, label };
+    }
+    renderElement(element, index, templateData) {
+        templateData.label.set(element.element.name, createMatches(element.filterData));
+    }
+    disposeTemplate(templateData) {
+    }
+}
+ScopesRenderer.ID = 'scope';
+class ScopeErrorRenderer {
+    get templateId() {
+        return ScopeErrorRenderer.ID;
+    }
+    renderTemplate(container) {
+        const wrapper = dom.append(container, $('.scope'));
+        const error = dom.append(wrapper, $('.error'));
+        return { error };
+    }
+    renderElement(element, index, templateData) {
+        templateData.error.innerText = element.element.name;
+    }
+    disposeTemplate() {
+    }
+}
+ScopeErrorRenderer.ID = 'scopeError';
 let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRenderer {
     constructor(linkDetector, menuService, contextKeyService, debugService, contextViewService) {
         super(debugService, contextViewService);
@@ -68,6 +324,7 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
                 if (success && variable.value !== value && focusedStackFrame) {
                     variable.setVariable(value, focusedStackFrame)
                         .then(() => {
+                        forgetScopes = false;
                         this.debugService.getViewModel().updateViews();
                     });
                 }
@@ -93,6 +350,25 @@ VariablesRenderer = ( __decorate([
     ( __param(3, IDebugService)),
     ( __param(4, IContextViewService))
 ], VariablesRenderer));
+class VariablesAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localize('variablesAriaTreeLabel', "Debug Variables"));
+    }
+    getAriaLabel(element) {
+        if (element instanceof Scope) {
+            return ( localize('variableScopeAriaLabel', "Scope {0}", element.name));
+        }
+        if (element instanceof Variable) {
+            return ( localize(
+                { key: 'variableAriaLabel', comment: ['Placeholders are variable name and variable value respectivly. They should not be translated.'] },
+                "{0}, value {1}",
+                element.name,
+                element.value
+            ));
+        }
+        return null;
+    }
+}
 const SET_VARIABLE_ID = 'debug.setVariable';
 CommandsRegistry.registerCommand({
     id: SET_VARIABLE_ID,
@@ -232,21 +508,30 @@ const BREAK_WHEN_VALUE_CHANGES_ID = 'debug.breakWhenValueChanges';
 CommandsRegistry.registerCommand({
     id: BREAK_WHEN_VALUE_CHANGES_ID,
     handler: async (accessor) => {
-        accessor.get(IDebugService);
+        const debugService = accessor.get(IDebugService);
+        if (dataBreakpointInfoResponse) {
+            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'write');
+        }
     }
 });
 const BREAK_WHEN_VALUE_IS_ACCESSED_ID = 'debug.breakWhenValueIsAccessed';
 CommandsRegistry.registerCommand({
     id: BREAK_WHEN_VALUE_IS_ACCESSED_ID,
     handler: async (accessor) => {
-        accessor.get(IDebugService);
+        const debugService = accessor.get(IDebugService);
+        if (dataBreakpointInfoResponse) {
+            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'readWrite');
+        }
     }
 });
 const BREAK_WHEN_VALUE_IS_READ_ID = 'debug.breakWhenValueIsRead';
 CommandsRegistry.registerCommand({
     id: BREAK_WHEN_VALUE_IS_READ_ID,
     handler: async (accessor) => {
-        accessor.get(IDebugService);
+        const debugService = accessor.get(IDebugService);
+        if (dataBreakpointInfoResponse) {
+            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'read');
+        }
     }
 });
 const COPY_EVALUATE_PATH_ID = 'debug.copyEvaluatePath';
@@ -284,4 +569,4 @@ registerAction2(class extends ViewAction {
         view.collapseAll();
     }
 });
-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 };
+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 };