@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.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 };