@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,46 @@
+import { matchesFuzzy } from '../../../../base/common/filters.js';
+import { splitGlobAware } from '../../../../base/common/glob.js';
+import { ReplEvaluationInput, ReplEvaluationResult } from '../common/replModel.js';
+import { Variable } from '../common/debugModel.js';
+class ReplFilter {
+    constructor() {
+        this._parsedQueries = [];
+    }
+    static { this.matchQuery = matchesFuzzy; }
+    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) );
+    }
+}
+export { ReplFilter };

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

@@ -0,0 +1,350 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, clearNode, $ as $$1, addDisposableListener } from '../../../../base/browser/dom.js';
+import { CountBadge } from '../../../../base/browser/ui/countBadge/countBadge.js';
+import { HighlightedLabel } from '../../../../base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { CachedListVirtualDelegate } from '../../../../base/browser/ui/list/list.js';
+import { createMatches } from '../../../../base/common/filters.js';
+import { dispose } from '../../../../base/common/lifecycle.js';
+import { basename } from '../../../../base/common/path.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { defaultCountBadgeStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ThemeIcon } from '../../../../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';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+var ReplGroupRenderer_1, ReplOutputElementRenderer_1, ReplVariablesRenderer_1;
+const $ = $$1;
+class ReplEvaluationInputsRenderer {
+    static { this.ID = 'replEvaluationInput'; }
+    get templateId() {
+        return ReplEvaluationInputsRenderer.ID;
+    }
+    renderTemplate(container) {
+        append(container, $('span.arrow' + ThemeIcon.asCSSSelector(debugConsoleEvaluationInput)));
+        const input = 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) {
+        templateData.label.dispose();
+    }
+}
+let ReplGroupRenderer = class ReplGroupRenderer {
+    static { ReplGroupRenderer_1 = this; }
+    static { this.ID = 'replGroup'; }
+    constructor(linkDetector, themeService) {
+        this.linkDetector = linkDetector;
+        this.themeService = themeService;
+    }
+    get templateId() {
+        return ReplGroupRenderer_1.ID;
+    }
+    renderTemplate(container) {
+        const label = append(container, $('.expression'));
+        return { label };
+    }
+    renderElement(element, _index, templateData) {
+        const replGroup = element.element;
+        clearNode(templateData.label);
+        const result = handleANSIOutput(replGroup.name, this.linkDetector, this.themeService, undefined);
+        templateData.label.appendChild(result);
+    }
+    disposeTemplate(_templateData) {
+    }
+};
+ReplGroupRenderer = ReplGroupRenderer_1 = ( __decorate([
+    ( __param(1, IThemeService))
+], ReplGroupRenderer));
+class ReplEvaluationResultsRenderer {
+    static { this.ID = 'replEvaluationResult'; }
+    get templateId() {
+        return ReplEvaluationResultsRenderer.ID;
+    }
+    constructor(linkDetector) {
+        this.linkDetector = linkDetector;
+    }
+    renderTemplate(container) {
+        const output = append(container, $('.evaluation-result.expression'));
+        const value = 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) {
+    }
+}
+let ReplOutputElementRenderer = class ReplOutputElementRenderer {
+    static { ReplOutputElementRenderer_1 = this; }
+    static { this.ID = 'outputReplElement'; }
+    constructor(linkDetector, editorService, labelService, themeService) {
+        this.linkDetector = linkDetector;
+        this.editorService = editorService;
+        this.labelService = labelService;
+        this.themeService = themeService;
+    }
+    get templateId() {
+        return ReplOutputElementRenderer_1.ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        container.classList.add('output');
+        const expression = append(container, $('.output.expression.value-and-source'));
+        data.container = container;
+        data.countContainer = append(expression, $('.count-badge-wrapper'));
+        data.count = ( new CountBadge(data.countContainer, {}, defaultCountBadgeStyles));
+        data.value = append(expression, $('span.value'));
+        data.source = append(expression, $('.source'));
+        data.toDispose = [];
+        data.toDispose.push(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));
+        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$1.Warning) ? 'warn' : (element.severity === Severity$1.Error) ? 'error' : (element.severity === Severity$1.Ignore) ? 'ignore' : 'info');
+        templateData.source.textContent = element.sourceData ? `${basename(element.sourceData.source.name)}:${element.sourceData.lineNumber}` : '';
+        templateData.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), templateData.source, 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 = ReplOutputElementRenderer_1 = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, ILabelService)),
+    ( __param(3, IThemeService))
+], ReplOutputElementRenderer));
+let ReplVariablesRenderer = class ReplVariablesRenderer extends AbstractExpressionsRenderer {
+    static { ReplVariablesRenderer_1 = this; }
+    static { this.ID = 'replVariable'; }
+    get templateId() {
+        return ReplVariablesRenderer_1.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.expression : element, node, data);
+    }
+    renderExpression(expression, data, highlights) {
+        const isReplVariable = expression instanceof ReplVariableElement;
+        if (isReplVariable || !expression.name) {
+            data.label.set('');
+            renderExpressionValue(isReplVariable ? expression.expression : 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 = ReplVariablesRenderer_1 = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IContextViewService))
+], ReplVariablesRenderer));
+class ReplRawObjectsRenderer {
+    static { this.ID = 'rawObject'; }
+    constructor(linkDetector) {
+        this.linkDetector = linkDetector;
+    }
+    get templateId() {
+        return ReplRawObjectsRenderer.ID;
+    }
+    renderTemplate(container) {
+        container.classList.add('output');
+        const expression = append(container, $('.output.expression'));
+        const name = append(expression, $('span.name'));
+        const label = ( new HighlightedLabel(name));
+        const value = 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) {
+        templateData.label.dispose();
+    }
+}
+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 ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/replViewer',
+            'debugConsole',
+            "Debug Console"
+        ));
+    }
+    getAriaLabel(element) {
+        if (element instanceof Variable) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/replViewer',
+                '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 ? ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/replViewer',
+                { 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 ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/replViewer',
+                'replRawObjectAriaLabel',
+                "Debug console variable {0}, value {1}",
+                element.name,
+                element.value
+            ));
+        }
+        if (element instanceof ReplGroup) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/replViewer',
+                'replGroup',
+                "Debug console group {0}",
+                element.name
+            ));
+        }
+        return '';
+    }
+}
+export { ReplAccessibilityProvider, ReplDataSource, ReplDelegate, ReplEvaluationInputsRenderer, ReplEvaluationResultsRenderer, ReplGroupRenderer, ReplOutputElementRenderer, ReplRawObjectsRenderer, ReplVariablesRenderer };

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

@@ -0,0 +1,127 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerColor, asCssVariableName, asCssVariable } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { IDebugService } from '../common/debug.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { STATUS_BAR_FOREGROUND, STATUS_BAR_BORDER, COMMAND_CENTER_BACKGROUND } from '../../../common/theme.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
+const STATUS_BAR_DEBUGGING_BACKGROUND = registerColor('statusBar.debuggingBackground', {
+    dark: '#CC6633',
+    light: '#CC6633',
+    hcDark: '#BA592C',
+    hcLight: '#B5200D'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
+    'statusBarDebuggingBackground',
+    "Status bar background color when a program is being debugged. The status bar is shown in the bottom of the window"
+)));
+const STATUS_BAR_DEBUGGING_FOREGROUND = registerColor('statusBar.debuggingForeground', {
+    dark: STATUS_BAR_FOREGROUND,
+    light: STATUS_BAR_FOREGROUND,
+    hcDark: STATUS_BAR_FOREGROUND,
+    hcLight: '#FFFFFF'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
+    'statusBarDebuggingForeground',
+    "Status bar foreground color when a program is being debugged. The status bar is shown in the bottom of the window"
+)));
+const STATUS_BAR_DEBUGGING_BORDER = registerColor('statusBar.debuggingBorder', {
+    dark: STATUS_BAR_BORDER,
+    light: STATUS_BAR_BORDER,
+    hcDark: STATUS_BAR_BORDER,
+    hcLight: STATUS_BAR_BORDER
+}, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
+    'statusBarDebuggingBorder',
+    "Status bar border color separating to the sidebar and editor when a program is being debugged. The status bar is shown in the bottom of the window"
+)));
+const COMMAND_CENTER_DEBUGGING_BACKGROUND = registerColor('commandCenter.debuggingBackground', {
+    dark: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 },
+    hcDark: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 },
+    light: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 },
+    hcLight: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 }
+}, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
+    'commandCenter-activeBackground',
+    "Command center background color when a program is being debugged"
+)), true);
+let StatusBarColorProvider = class StatusBarColorProvider {
+    set enabled(enabled) {
+        if (enabled === !!this.disposable) {
+            return;
+        }
+        if (enabled) {
+            this.disposable = this.statusbarService.overrideStyle({
+                priority: 10,
+                foreground: STATUS_BAR_DEBUGGING_FOREGROUND,
+                background: STATUS_BAR_DEBUGGING_BACKGROUND,
+                border: STATUS_BAR_DEBUGGING_BORDER,
+            });
+        }
+        else {
+            this.disposable.dispose();
+            this.disposable = undefined;
+        }
+    }
+    constructor(debugService, contextService, statusbarService, layoutService, configurationService) {
+        this.debugService = debugService;
+        this.contextService = contextService;
+        this.statusbarService = statusbarService;
+        this.layoutService = layoutService;
+        this.configurationService = configurationService;
+        this.disposables = ( new DisposableStore());
+        this.debugService.onDidChangeState(this.update, this, this.disposables);
+        this.contextService.onDidChangeWorkbenchState(this.update, this, this.disposables);
+        this.configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('debug.enableStatusBarColor') || e.affectsConfiguration('debug.toolBarLocation')) {
+                this.update();
+            }
+        }, this.disposables);
+        this.update();
+    }
+    update() {
+        const debugConfig = this.configurationService.getValue('debug');
+        const isInDebugMode = isStatusbarInDebugMode(this.debugService.state, this.debugService.getModel().getSessions());
+        if (!debugConfig.enableStatusBarColor) {
+            this.enabled = false;
+        }
+        else {
+            this.enabled = isInDebugMode;
+        }
+        const isInCommandCenter = debugConfig.toolBarLocation === 'commandCenter';
+        this.layoutService.mainContainer.style.setProperty(asCssVariableName(COMMAND_CENTER_BACKGROUND), isInCommandCenter && isInDebugMode
+            ? asCssVariable(COMMAND_CENTER_DEBUGGING_BACKGROUND)
+            : '');
+    }
+    dispose() {
+        this.disposable?.dispose();
+        this.disposables.dispose();
+    }
+};
+StatusBarColorProvider = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IStatusbarService)),
+    ( __param(3, ILayoutService)),
+    ( __param(4, IConfigurationService))
+], StatusBarColorProvider));
+function isStatusbarInDebugMode(state, sessions) {
+    if (state === 0  || state === 1  || sessions.every(s => s.suppressDebugStatusbar || s.configuration?.noDebug)) {
+        return false;
+    }
+    return true;
+}
+export { COMMAND_CENTER_DEBUGGING_BACKGROUND, STATUS_BAR_DEBUGGING_BACKGROUND, STATUS_BAR_DEBUGGING_BORDER, STATUS_BAR_DEBUGGING_FOREGROUND, StatusBarColorProvider, isStatusbarInDebugMode };