@codingame/monaco-vscode-api 1.78.8 → 1.79.0

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

@@ -0,0 +1,46 @@
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { splitGlobAware } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { ReplEvaluationInput, ReplEvaluationResult } from '../common/replModel.js';
+import { Variable } from '../common/debugModel.js';
+class ReplFilter {
+    constructor() {
+        this._parsedQueries = [];
+    }
+    set filterQuery(query) {
+        this._parsedQueries = [];
+        query = query.trim();
+        if (query && query !== '') {
+            const filters = ( splitGlobAware(query, ',').map(s => s.trim())).filter(s => !!s.length);
+            for (const f of filters) {
+                if (f.startsWith('!')) {
+                    this._parsedQueries.push({ type: 'exclude', query: f.slice(1) });
+                }
+                else {
+                    this._parsedQueries.push({ type: 'include', query: f });
+                }
+            }
+        }
+    }
+    filter(element, parentVisibility) {
+        if (element instanceof ReplEvaluationInput || element instanceof ReplEvaluationResult || element instanceof Variable) {
+            return 1 ;
+        }
+        let includeQueryPresent = false;
+        let includeQueryMatched = false;
+        const text = ( element.toString(true));
+        for (const { type, query } of this._parsedQueries) {
+            if (type === 'exclude' && ReplFilter.matchQuery(query, text)) {
+                return false;
+            }
+            else if (type === 'include') {
+                includeQueryPresent = true;
+                if (ReplFilter.matchQuery(query, text)) {
+                    includeQueryMatched = true;
+                }
+            }
+        }
+        return includeQueryPresent ? includeQueryMatched : ((typeof parentVisibility !== 'undefined' ? parentVisibility : 1) );
+    }
+}
+ReplFilter.matchQuery = matchesFuzzy;
+export { ReplFilter };

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

@@ -0,0 +1,330 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CountBadge } from 'monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.js';
+import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { CachedListVirtualDelegate } from 'monaco-editor/esm/vs/base/browser/ui/list/list.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { defaultCountBadgeStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { AbstractExpressionsRenderer, renderExpressionValue, renderVariable } from './baseDebugView.js';
+import { handleANSIOutput } from './debugANSIHandling.js';
+import { debugConsoleEvaluationInput } from './debugIcons.js';
+import { IDebugService } from '../common/debug.js';
+import { Variable } from '../common/debugModel.js';
+import { ReplVariableElement, ReplEvaluationResult, ReplOutputElement, ReplEvaluationInput, ReplGroup, RawObjectReplElement } from '../common/replModel.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+const $ = dom.$;
+class ReplEvaluationInputsRenderer {
+    get templateId() {
+        return ReplEvaluationInputsRenderer.ID;
+    }
+    renderTemplate(container) {
+        dom.append(container, $('span.arrow' + ThemeIcon.asCSSSelector(debugConsoleEvaluationInput)));
+        const input = dom.append(container, $('.expression'));
+        const label = ( new HighlightedLabel(input));
+        return { label };
+    }
+    renderElement(element, index, templateData) {
+        const evaluation = element.element;
+        templateData.label.set(evaluation.value, createMatches(element.filterData));
+    }
+    disposeTemplate(templateData) {
+    }
+}
+ReplEvaluationInputsRenderer.ID = 'replEvaluationInput';
+let ReplGroupRenderer = class ReplGroupRenderer {
+    constructor(linkDetector, themeService) {
+        this.linkDetector = linkDetector;
+        this.themeService = themeService;
+    }
+    get templateId() {
+        return ReplGroupRenderer.ID;
+    }
+    renderTemplate(container) {
+        const label = dom.append(container, $('.expression'));
+        return { label };
+    }
+    renderElement(element, _index, templateData) {
+        const replGroup = element.element;
+        dom.clearNode(templateData.label);
+        const result = handleANSIOutput(replGroup.name, this.linkDetector, this.themeService, undefined);
+        templateData.label.appendChild(result);
+    }
+    disposeTemplate(_templateData) {
+    }
+};
+ReplGroupRenderer.ID = 'replGroup';
+ReplGroupRenderer = ( __decorate([
+    ( __param(1, IThemeService))
+], ReplGroupRenderer));
+class ReplEvaluationResultsRenderer {
+    get templateId() {
+        return ReplEvaluationResultsRenderer.ID;
+    }
+    constructor(linkDetector) {
+        this.linkDetector = linkDetector;
+    }
+    renderTemplate(container) {
+        const output = dom.append(container, $('.evaluation-result.expression'));
+        const value = dom.append(output, $('span.value'));
+        return { value };
+    }
+    renderElement(element, index, templateData) {
+        const expression = element.element;
+        renderExpressionValue(expression, templateData.value, {
+            showHover: false,
+            colorize: true,
+            linkDetector: this.linkDetector
+        });
+    }
+    disposeTemplate(templateData) {
+    }
+}
+ReplEvaluationResultsRenderer.ID = 'replEvaluationResult';
+let ReplOutputElementRenderer = class ReplOutputElementRenderer {
+    constructor(linkDetector, editorService, labelService, themeService) {
+        this.linkDetector = linkDetector;
+        this.editorService = editorService;
+        this.labelService = labelService;
+        this.themeService = themeService;
+    }
+    get templateId() {
+        return ReplOutputElementRenderer.ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        container.classList.add('output');
+        const expression = dom.append(container, $('.output.expression.value-and-source'));
+        data.container = container;
+        data.countContainer = dom.append(expression, $('.count-badge-wrapper'));
+        data.count = ( new CountBadge(data.countContainer, {}, defaultCountBadgeStyles));
+        data.value = dom.append(expression, $('span.value'));
+        data.source = dom.append(expression, $('.source'));
+        data.toDispose = [];
+        data.toDispose.push(dom.addDisposableListener(data.source, 'click', e => {
+            e.preventDefault();
+            e.stopPropagation();
+            const source = data.getReplElementSource();
+            if (source) {
+                source.source.openInEditor(this.editorService, {
+                    startLineNumber: source.lineNumber,
+                    startColumn: source.column,
+                    endLineNumber: source.lineNumber,
+                    endColumn: source.column
+                });
+            }
+        }));
+        return data;
+    }
+    renderElement({ element }, index, templateData) {
+        this.setElementCount(element, templateData);
+        templateData.elementListener = element.onDidChangeCount(() => this.setElementCount(element, templateData));
+        dom.clearNode(templateData.value);
+        templateData.value.className = 'value';
+        templateData.value.appendChild(handleANSIOutput(element.value, this.linkDetector, this.themeService, element.session.root));
+        templateData.value.classList.add((element.severity === Severity.Warning) ? 'warn' : (element.severity === Severity.Error) ? 'error' : (element.severity === Severity.Ignore) ? 'ignore' : 'info');
+        templateData.source.textContent = element.sourceData ? `${basename(element.sourceData.source.name)}:${element.sourceData.lineNumber}` : '';
+        templateData.source.title = element.sourceData ? `${this.labelService.getUriLabel(element.sourceData.source.uri)}:${element.sourceData.lineNumber}` : '';
+        templateData.getReplElementSource = () => element.sourceData;
+    }
+    setElementCount(element, templateData) {
+        if (element.count >= 2) {
+            templateData.count.setCount(element.count);
+            templateData.countContainer.hidden = false;
+        }
+        else {
+            templateData.countContainer.hidden = true;
+        }
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+    disposeElement(_element, _index, templateData) {
+        templateData.elementListener.dispose();
+    }
+};
+ReplOutputElementRenderer.ID = 'outputReplElement';
+ReplOutputElementRenderer = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, ILabelService)),
+    ( __param(3, IThemeService))
+], ReplOutputElementRenderer));
+let ReplVariablesRenderer = class ReplVariablesRenderer extends AbstractExpressionsRenderer {
+    get templateId() {
+        return ReplVariablesRenderer.ID;
+    }
+    constructor(linkDetector, debugService, contextViewService) {
+        super(debugService, contextViewService);
+        this.linkDetector = linkDetector;
+    }
+    renderElement(node, _index, data) {
+        const element = node.element;
+        super.renderExpressionElement(element instanceof ReplVariableElement ? element.expr : element, node, data);
+    }
+    renderExpression(expression, data, highlights) {
+        const isReplVariable = expression instanceof ReplVariableElement;
+        if (isReplVariable || !expression.name) {
+            data.label.set('');
+            renderExpressionValue(isReplVariable ? expression.expr : expression, data.value, { showHover: false, colorize: true, linkDetector: this.linkDetector });
+            data.expression.classList.remove('nested-variable');
+        }
+        else {
+            renderVariable(expression, data, true, highlights, this.linkDetector);
+            data.expression.classList.toggle('nested-variable', isNestedVariable(expression));
+        }
+    }
+    getInputBoxOptions(expression) {
+        return undefined;
+    }
+};
+ReplVariablesRenderer.ID = 'replVariable';
+ReplVariablesRenderer = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IContextViewService))
+], ReplVariablesRenderer));
+class ReplRawObjectsRenderer {
+    constructor(linkDetector) {
+        this.linkDetector = linkDetector;
+    }
+    get templateId() {
+        return ReplRawObjectsRenderer.ID;
+    }
+    renderTemplate(container) {
+        container.classList.add('output');
+        const expression = dom.append(container, $('.output.expression'));
+        const name = dom.append(expression, $('span.name'));
+        const label = ( new HighlightedLabel(name));
+        const value = dom.append(expression, $('span.value'));
+        return { container, expression, name, label, value };
+    }
+    renderElement(node, index, templateData) {
+        const element = node.element;
+        templateData.label.set(element.name ? `${element.name}:` : '', createMatches(node.filterData));
+        if (element.name) {
+            templateData.name.textContent = `${element.name}:`;
+        }
+        else {
+            templateData.name.textContent = '';
+        }
+        renderExpressionValue(element.value, templateData.value, {
+            showHover: false,
+            linkDetector: this.linkDetector
+        });
+    }
+    disposeTemplate(templateData) {
+    }
+}
+ReplRawObjectsRenderer.ID = 'rawObject';
+function isNestedVariable(element) {
+    return element instanceof Variable && (element.parent instanceof ReplEvaluationResult || element.parent instanceof Variable);
+}
+class ReplDelegate extends CachedListVirtualDelegate {
+    constructor(configurationService, replOptions) {
+        super();
+        this.configurationService = configurationService;
+        this.replOptions = replOptions;
+    }
+    getHeight(element) {
+        const config = this.configurationService.getValue('debug');
+        if (!config.console.wordWrap) {
+            return this.estimateHeight(element, true);
+        }
+        return super.getHeight(element);
+    }
+    estimateHeight(element, ignoreValueLength = false) {
+        const lineHeight = this.replOptions.replConfiguration.lineHeight;
+        const countNumberOfLines = (str) => str.match(/\n/g)?.length ?? 0;
+        const hasValue = (e) => typeof e.value === 'string';
+        if (hasValue(element) && !isNestedVariable(element)) {
+            const value = element.value;
+            const valueRows = countNumberOfLines(value)
+                + (ignoreValueLength ? 0 : Math.floor(value.length / 70))
+                + (element instanceof ReplOutputElement ? 0 : 1);
+            return Math.max(valueRows, 1) * lineHeight;
+        }
+        return lineHeight;
+    }
+    getTemplateId(element) {
+        if (element instanceof Variable || element instanceof ReplVariableElement) {
+            return ReplVariablesRenderer.ID;
+        }
+        if (element instanceof ReplEvaluationResult) {
+            return ReplEvaluationResultsRenderer.ID;
+        }
+        if (element instanceof ReplEvaluationInput) {
+            return ReplEvaluationInputsRenderer.ID;
+        }
+        if (element instanceof ReplOutputElement) {
+            return ReplOutputElementRenderer.ID;
+        }
+        if (element instanceof ReplGroup) {
+            return ReplGroupRenderer.ID;
+        }
+        return ReplRawObjectsRenderer.ID;
+    }
+    hasDynamicHeight(element) {
+        if (isNestedVariable(element)) {
+            return false;
+        }
+        return ( element.toString()).length > 0;
+    }
+}
+function isDebugSession(obj) {
+    return typeof obj.getReplElements === 'function';
+}
+class ReplDataSource {
+    hasChildren(element) {
+        if (isDebugSession(element)) {
+            return true;
+        }
+        return !!element.hasChildren;
+    }
+    getChildren(element) {
+        if (isDebugSession(element)) {
+            return Promise.resolve(element.getReplElements());
+        }
+        return Promise.resolve(element.getChildren());
+    }
+}
+class ReplAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localize('debugConsole', "Debug Console"));
+    }
+    getAriaLabel(element) {
+        if (element instanceof Variable) {
+            return ( localize(
+                'replVariableAriaLabel',
+                "Variable {0}, value {1}",
+                element.name,
+                element.value
+            ));
+        }
+        if (element instanceof ReplOutputElement || element instanceof ReplEvaluationInput || element instanceof ReplEvaluationResult) {
+            return element.value + (element instanceof ReplOutputElement && element.count > 1 ? ( localize(
+                { key: 'occurred', comment: ['Front will the value of the debug console element. Placeholder will be replaced by a number which represents occurrance count.'] },
+                ", occurred {0} times",
+                element.count
+            )) : '');
+        }
+        if (element instanceof RawObjectReplElement) {
+            return ( localize(
+                'replRawObjectAriaLabel',
+                "Debug console variable {0}, value {1}",
+                element.name,
+                element.value
+            ));
+        }
+        if (element instanceof ReplGroup) {
+            return ( localize('replGroup', "Debug console group {0}", element.name));
+        }
+        return '';
+    }
+}
+export { ReplAccessibilityProvider, ReplDataSource, ReplDelegate, ReplEvaluationInputsRenderer, ReplEvaluationResultsRenderer, ReplGroupRenderer, ReplOutputElementRenderer, ReplRawObjectsRenderer, ReplVariablesRenderer };