@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/callHierarchy/browser/callHierarchyTree.js

@@ -0,0 +1,119 @@
+import { CallHierarchyModel } from '../common/callHierarchy.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { SymbolKinds } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+class Call {
+    constructor(item, locations, model, parent) {
+        this.item = item;
+        this.locations = locations;
+        this.model = model;
+        this.parent = parent;
+    }
+    static compare(a, b) {
+        let res = compare(( a.item.uri.toString()), ( b.item.uri.toString()));
+        if (res === 0) {
+            res = Range.compareRangesUsingStarts(a.item.range, b.item.range);
+        }
+        return res;
+    }
+}
+class DataSource {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    hasChildren() {
+        return true;
+    }
+    async getChildren(element) {
+        if (element instanceof CallHierarchyModel) {
+            return ( element.roots.map(root => ( new Call(root, undefined, element, undefined))));
+        }
+        const { model, item } = element;
+        if (this.getDirection() === "outgoingCalls" ) {
+            return ( (await model.resolveOutgoingCalls(item, CancellationToken.None)).map(call => {
+                return ( new Call(call.to, ( call.fromRanges.map(range => ({ range, uri: item.uri }))), model, element));
+            }));
+        }
+        else {
+            return ( (await model.resolveIncomingCalls(item, CancellationToken.None)).map(call => {
+                return ( new Call(call.from, ( call.fromRanges.map(range => ({ range, uri: call.from.uri }))), model, element));
+            }));
+        }
+    }
+}
+class Sorter {
+    compare(element, otherElement) {
+        return Call.compare(element, otherElement);
+    }
+}
+class IdentityProvider {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    getId(element) {
+        let res = this.getDirection() + JSON.stringify(element.item.uri) + JSON.stringify(element.item.range);
+        if (element.parent) {
+            res += this.getId(element.parent);
+        }
+        return res;
+    }
+}
+class CallRenderingTemplate {
+    constructor(icon, label) {
+        this.icon = icon;
+        this.label = label;
+    }
+}
+class CallRenderer {
+    constructor() {
+        this.templateId = CallRenderer.id;
+    }
+    renderTemplate(container) {
+        container.classList.add('callhierarchy-element');
+        const icon = document.createElement('div');
+        container.appendChild(icon);
+        const label = ( new IconLabel(container, { supportHighlights: true }));
+        return ( new CallRenderingTemplate(icon, label));
+    }
+    renderElement(node, _index, template) {
+        const { element, filterData } = node;
+        const deprecated = element.item.tags?.includes(1 );
+        template.icon.className = '';
+        template.icon.classList.add('inline', ...ThemeIcon.asClassNameArray(SymbolKinds.toIcon(element.item.kind)));
+        template.label.setLabel(element.item.name, element.item.detail, { labelEscapeNewLines: true, matches: createMatches(filterData), strikethrough: deprecated });
+    }
+    disposeTemplate(template) {
+        template.label.dispose();
+    }
+}
+CallRenderer.id = 'CallRenderer';
+class VirtualDelegate {
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(_element) {
+        return CallRenderer.id;
+    }
+}
+class AccessibilityProvider {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    getWidgetAriaLabel() {
+        return ( localize('tree.aria', "Call Hierarchy"));
+    }
+    getAriaLabel(element) {
+        if (this.getDirection() === "outgoingCalls" ) {
+            return ( localize('from', "calls from {0}", element.item.name));
+        }
+        else {
+            return ( localize('to', "callers of {0}", element.item.name));
+        }
+    }
+}
+export { AccessibilityProvider, Call, CallRenderer, DataSource, IdentityProvider, Sorter, VirtualDelegate };

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

@@ -12,12 +12,18 @@ import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
 import { defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
 import { IDebugService } from '../common/debug.js';
-import { Variable, Expression, ExpressionContainer } from '../common/debugModel.js';
+import { Expression, Variable, ExpressionContainer } from '../common/debugModel.js';
 import { ReplEvaluationResult } from '../common/replModel.js';
 const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
 const booleanRegex = /^(true|false)$/i;
 const stringRegex = /^(['"]).*\1$/;
 const $ = dom.$;
+function renderViewTree(container) {
+    const treeContainer = $('.');
+    treeContainer.classList.add('debug-view-content');
+    container.appendChild(treeContainer);
+    return treeContainer;
+}
 function renderExpressionValue(expressionOrValue, container, options) {
     let value = typeof expressionOrValue === 'string' ? expressionOrValue : expressionOrValue.value;
     container.className = 'value';
@@ -189,4 +195,4 @@ AbstractExpressionsRenderer = ( __decorate([
     ( __param(0, IDebugService)),
     ( __param(1, IContextViewService))
 ], AbstractExpressionsRenderer));
-export { AbstractExpressionsRenderer, renderExpressionValue, renderVariable };
+export { AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree };

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

@@ -18,7 +18,7 @@ import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { GlyphMarginLane, OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
@@ -37,6 +37,7 @@ const $ = dom.$;
 const breakpointHelperDecoration = {
     description: 'breakpoint-helper-decoration',
     glyphMarginClassName: ThemeIcon.asClassName(debugBreakpointHint),
+    glyphMargin: { position: GlyphMarginLane.Right },
     stickiness: 1
 };
 function createBreakpointDecorations(accessor, model, breakpoints, state, breakpointsActivated, showBreakpointsInOverviewRuler) {
@@ -112,6 +113,7 @@ function getBreakpointDecorationOptions(accessor, model, breakpoint, state, brea
     const renderInline = breakpoint.column && (hasOtherBreakpointsOnLine || breakpoint.column > model.getLineFirstNonWhitespaceColumn(breakpoint.lineNumber));
     return {
         description: 'breakpoint-decoration',
+        glyphMargin: { position: GlyphMarginLane.Right },
         glyphMarginClassName: ThemeIcon.asClassName(icon),
         glyphMarginHoverMessage,
         stickiness: 1 ,
@@ -120,7 +122,8 @@ function getBreakpointDecorationOptions(accessor, model, breakpoint, state, brea
             inlineClassName: `debug-breakpoint-placeholder`,
             inlineClassNameAffectsLetterSpacing: true
         } : undefined,
-        overviewRuler: overviewRulerDecoration
+        overviewRuler: overviewRulerDecoration,
+        zIndex: 9999
     };
 }
 async function requestBreakpointCandidateLocations(model, lineNumbers, session) {
@@ -208,7 +211,12 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
                 return;
             }
             const model = this.editor.getModel();
-            if (!e.target.position || !model || e.target.type !== 2  || e.target.detail.isAfterLines || !this.marginFreeFromNonDebugDecorations(e.target.position.lineNumber)) {
+            if (!e.target.position
+                || !model
+                || e.target.type !== 2
+                || e.target.detail.isAfterLines
+                || !this.marginFreeFromNonDebugDecorations(e.target.position.lineNumber)
+                    && !e.target.element?.className.includes('breakpoint')) {
                 return;
             }
             const canSetBreakpoints = this.debugService.canSetBreakpointsIn(model);
@@ -429,7 +437,7 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
         if (decorations) {
             for (const { options } of decorations) {
                 const clz = options.glyphMarginClassName;
-                if (clz && (!clz.includes('codicon-') || clz.includes('codicon-testing-') || clz.includes('codicon-merge-') || clz.includes('codicon-arrow-'))) {
+                if (clz && (!clz.includes('codicon-') || clz.includes('codicon-testing-') || clz.includes('codicon-merge-') || clz.includes('codicon-arrow-') || clz.includes('codicon-loading'))) {
                     return false;
                 }
             }

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

@@ -195,6 +195,11 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
         this.input.layout({ height: heightInPixel, width: widthInPixel - 113 });
         this.centerInputVertically();
     }
+    _onWidth(widthInPixel) {
+        if (typeof this.heightInPx === 'number') {
+            this._doLayout(this.heightInPx, widthInPixel);
+        }
+    }
     createBreakpointInput(container) {
         const scopedContextKeyService = this.contextKeyService.createScoped(container);
         this.toDispose.push(scopedContextKeyService);