@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

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

@@ -0,0 +1,105 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/exceptionWidget.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ZoneWidget } from 'monaco-editor/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget.js';
+import { EDITOR_CONTRIBUTION_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.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 { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { LinkDetector } from './linkDetector.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { widgetClose } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+
+const $ = dom.$;
+const debugExceptionWidgetBorder = registerColor('debugExceptionWidget.border', { dark: '#a31515', light: '#a31515', hcDark: '#a31515', hcLight: '#a31515' }, ( nls.localize('debugExceptionWidgetBorder', 'Exception widget border color.')));
+const debugExceptionWidgetBackground = registerColor('debugExceptionWidget.background', { dark: '#420b0d', light: '#f1dfde', hcDark: '#420b0d', hcLight: '#f1dfde' }, ( nls.localize('debugExceptionWidgetBackground', 'Exception widget background color.')));
+let ExceptionWidget = class ExceptionWidget extends ZoneWidget {
+    constructor(editor, exceptionInfo, debugSession, themeService, instantiationService) {
+        super(editor, { showFrame: true, showArrow: true, isAccessible: true, frameWidth: 1, className: 'exception-widget-container' });
+        this.exceptionInfo = exceptionInfo;
+        this.debugSession = debugSession;
+        this.instantiationService = instantiationService;
+        this.applyTheme(themeService.getColorTheme());
+        this._disposables.add(themeService.onDidColorThemeChange(this.applyTheme.bind(this)));
+        this.create();
+        const onDidLayoutChangeScheduler = ( new RunOnceScheduler(() => this._doLayout(undefined, undefined), 50));
+        this._disposables.add(this.editor.onDidLayoutChange(() => onDidLayoutChangeScheduler.schedule()));
+        this._disposables.add(onDidLayoutChangeScheduler);
+    }
+    applyTheme(theme) {
+        this.backgroundColor = theme.getColor(debugExceptionWidgetBackground);
+        const frameColor = theme.getColor(debugExceptionWidgetBorder);
+        this.style({
+            arrowColor: frameColor,
+            frameColor: frameColor
+        });
+    }
+    _applyStyles() {
+        if (this.container) {
+            this.container.style.backgroundColor = this.backgroundColor ? ( this.backgroundColor.toString()) : '';
+        }
+        super._applyStyles();
+    }
+    _fillContainer(container) {
+        this.setCssClass('exception-widget');
+        const fontInfo = this.editor.getOption(49 );
+        container.style.fontSize = `${fontInfo.fontSize}px`;
+        container.style.lineHeight = `${fontInfo.lineHeight}px`;
+        container.tabIndex = 0;
+        const title = $('.title');
+        const label = $('.label');
+        dom.append(title, label);
+        const actions = $('.actions');
+        dom.append(title, actions);
+        label.textContent = this.exceptionInfo.id ? ( nls.localize(
+            'exceptionThrownWithId',
+            'Exception has occurred: {0}',
+            this.exceptionInfo.id
+        )) : ( nls.localize('exceptionThrown', 'Exception has occurred.'));
+        let ariaLabel = label.textContent;
+        const actionBar = ( new ActionBar(actions));
+        actionBar.push(( new Action('editor.closeExceptionWidget', ( nls.localize('close', "Close")), ThemeIcon.asClassName(widgetClose), true, async () => {
+            const contribution = this.editor.getContribution(EDITOR_CONTRIBUTION_ID);
+            contribution?.closeExceptionWidget();
+        })), { label: false, icon: true });
+        dom.append(container, title);
+        if (this.exceptionInfo.description) {
+            const description = $('.description');
+            description.textContent = this.exceptionInfo.description;
+            ariaLabel += ', ' + this.exceptionInfo.description;
+            dom.append(container, description);
+        }
+        if (this.exceptionInfo.details && this.exceptionInfo.details.stackTrace) {
+            const stackTrace = $('.stack-trace');
+            const linkDetector = this.instantiationService.createInstance(LinkDetector);
+            const linkedStackTrace = linkDetector.linkify(this.exceptionInfo.details.stackTrace, true, this.debugSession ? this.debugSession.root : undefined);
+            stackTrace.appendChild(linkedStackTrace);
+            dom.append(container, stackTrace);
+            ariaLabel += ', ' + this.exceptionInfo.details.stackTrace;
+        }
+        container.setAttribute('aria-label', ariaLabel);
+    }
+    _doLayout(_heightInPixel, _widthInPixel) {
+        this.container.style.height = 'initial';
+        const lineHeight = this.editor.getOption(65 );
+        const arrowHeight = Math.round(lineHeight / 3);
+        const computedLinesNumber = Math.ceil((this.container.offsetHeight + arrowHeight) / lineHeight);
+        this._relayout(computedLinesNumber);
+    }
+    focus() {
+        this.container?.focus();
+    }
+    hasFocus() {
+        return dom.isAncestor(document.activeElement, this.container);
+    }
+};
+ExceptionWidget = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, IInstantiationService))
+], ExceptionWidget));
+
+export { ExceptionWidget };

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

@@ -0,0 +1,231 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+
+const CONTROL_CODES = '\\u0000-\\u0020\\u007f-\\u009f';
+const WEB_LINK_REGEX = ( new RegExp(
+    '(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s' + CONTROL_CODES + '"]{2,}[^\\s' + CONTROL_CODES + '"\')}\\],:;.!?]',
+    'ug'
+));
+const WIN_ABSOLUTE_PATH = /(?:[a-zA-Z]:(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_RELATIVE_PATH = /(?:(?:\~|\.)(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_PATH = ( new RegExp(`(${WIN_ABSOLUTE_PATH.source}|${WIN_RELATIVE_PATH.source})`));
+const POSIX_PATH = /((?:\~|\.)?(?:\/[\w\.-]*)+)/;
+const LINE_COLUMN = /(?:\:([\d]+))?(?:\:([\d]+))?/;
+const PATH_LINK_REGEX = ( new RegExp(
+    `${platform.isWindows ? WIN_PATH.source : POSIX_PATH.source}${LINE_COLUMN.source}`,
+    'g'
+));
+const LINE_COLUMN_REGEX = /:([\d]+)(?::([\d]+))?$/;
+const MAX_LENGTH = 2000;
+let LinkDetector = class LinkDetector {
+    constructor(editorService, fileService, openerService, pathService, tunnelService, environmentService, configurationService) {
+        this.editorService = editorService;
+        this.fileService = fileService;
+        this.openerService = openerService;
+        this.pathService = pathService;
+        this.tunnelService = tunnelService;
+        this.environmentService = environmentService;
+        this.configurationService = configurationService;
+    }
+    linkify(text, splitLines, workspaceFolder, includeFulltext) {
+        if (splitLines) {
+            const lines = text.split('\n');
+            for (let i = 0; i < lines.length - 1; i++) {
+                lines[i] = lines[i] + '\n';
+            }
+            if (!lines[lines.length - 1]) {
+                lines.pop();
+            }
+            const elements = ( lines.map(line => this.linkify(line, false, workspaceFolder, includeFulltext)));
+            if (elements.length === 1) {
+                return elements[0];
+            }
+            const container = document.createElement('span');
+            elements.forEach(e => container.appendChild(e));
+            return container;
+        }
+        const container = document.createElement('span');
+        for (const part of this.detectLinks(text)) {
+            try {
+                switch (part.kind) {
+                    case 'text':
+                        container.appendChild(document.createTextNode(part.value));
+                        break;
+                    case 'web':
+                        container.appendChild(this.createWebLink(includeFulltext ? text : undefined, part.value));
+                        break;
+                    case 'path': {
+                        const path = part.captures[0];
+                        const lineNumber = part.captures[1] ? Number(part.captures[1]) : 0;
+                        const columnNumber = part.captures[2] ? Number(part.captures[2]) : 0;
+                        container.appendChild(this.createPathLink(includeFulltext ? text : undefined, part.value, path, lineNumber, columnNumber, workspaceFolder));
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                container.appendChild(document.createTextNode(part.value));
+            }
+        }
+        return container;
+    }
+    createWebLink(fulltext, url) {
+        const link = this.createLink(url);
+        let uri = ( URI.parse(url));
+        const lineCol = LINE_COLUMN_REGEX.exec(uri.path);
+        if (lineCol) {
+            uri = uri.with({
+                path: uri.path.slice(0, lineCol.index),
+                fragment: `L${lineCol[0].slice(1)}`
+            });
+        }
+        this.decorateLink(link, uri, fulltext, async () => {
+            if (uri.scheme === Schemas.file) {
+                const fsPath = uri.fsPath;
+                const path$1 = await this.pathService.path;
+                const fileUrl = path.normalize(((path$1.sep === path.posix.sep) && platform.isWindows) ? fsPath.replace(/\\/g, path.posix.sep) : fsPath);
+                const fileUri = ( URI.parse(fileUrl));
+                const exists = await this.fileService.exists(fileUri);
+                if (!exists) {
+                    return;
+                }
+                await this.editorService.openEditor({
+                    resource: fileUri,
+                    options: {
+                        pinned: true,
+                        selection: lineCol ? { startLineNumber: +lineCol[1], startColumn: +lineCol[2] } : undefined,
+                    },
+                });
+                return;
+            }
+            this.openerService.open(url, { allowTunneling: (!!this.environmentService.remoteAuthority && this.configurationService.getValue('remote.forwardOnOpen')) });
+        });
+        return link;
+    }
+    createPathLink(fulltext, text, path$1, lineNumber, columnNumber, workspaceFolder) {
+        if (path$1[0] === '/' && path$1[1] === '/') {
+            return document.createTextNode(text);
+        }
+        const options = { selection: { startLineNumber: lineNumber, startColumn: columnNumber } };
+        if (path$1[0] === '.') {
+            if (!workspaceFolder) {
+                return document.createTextNode(text);
+            }
+            const uri = workspaceFolder.toResource(path$1);
+            const link = this.createLink(text);
+            this.decorateLink(link, uri, fulltext, (preserveFocus) => this.editorService.openEditor({ resource: uri, options: { ...options, preserveFocus } }));
+            return link;
+        }
+        if (path$1[0] === '~') {
+            const userHome = this.pathService.resolvedUserHome;
+            if (userHome) {
+                path$1 = path.join(userHome.fsPath, path$1.substring(1));
+            }
+        }
+        const link = this.createLink(text);
+        link.tabIndex = 0;
+        const uri = URI.file(path.normalize(path$1));
+        this.fileService.stat(uri).then(stat => {
+            if (stat.isDirectory) {
+                return;
+            }
+            this.decorateLink(link, uri, fulltext, (preserveFocus) => this.editorService.openEditor({ resource: uri, options: { ...options, preserveFocus } }));
+        }).catch(() => {
+        });
+        return link;
+    }
+    createLink(text) {
+        const link = document.createElement('a');
+        link.textContent = text;
+        return link;
+    }
+    decorateLink(link, uri, fulltext, onClick) {
+        link.classList.add('link');
+        const followLink = this.tunnelService.canTunnel(uri) ? ( localize('followForwardedLink', "follow link using forwarded port")) : ( localize('followLink', "follow link"));
+        link.title = fulltext
+            ? (platform.isMacintosh ? ( localize('fileLinkWithPathMac', "Cmd + click to {0}\n{1}", followLink, fulltext)) : ( localize('fileLinkWithPath', "Ctrl + click to {0}\n{1}", followLink, fulltext)))
+            : (platform.isMacintosh ? ( localize('fileLinkMac', "Cmd + click to {0}", followLink)) : ( localize('fileLink', "Ctrl + click to {0}", followLink)));
+        link.onmousemove = (event) => { link.classList.toggle('pointer', platform.isMacintosh ? event.metaKey : event.ctrlKey); };
+        link.onmouseleave = () => link.classList.remove('pointer');
+        link.onclick = (event) => {
+            const selection = window.getSelection();
+            if (!selection || selection.type === 'Range') {
+                return;
+            }
+            if (!(platform.isMacintosh ? event.metaKey : event.ctrlKey)) {
+                return;
+            }
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            onClick(false);
+        };
+        link.onkeydown = e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.keyCode === 3  || event.keyCode === 10 ) {
+                event.preventDefault();
+                event.stopPropagation();
+                onClick(event.keyCode === 10 );
+            }
+        };
+    }
+    detectLinks(text) {
+        if (text.length > MAX_LENGTH) {
+            return [{ kind: 'text', value: text, captures: [] }];
+        }
+        const regexes = [WEB_LINK_REGEX, PATH_LINK_REGEX];
+        const kinds = ['web', 'path'];
+        const result = [];
+        const splitOne = (text, regexIndex) => {
+            if (regexIndex >= regexes.length) {
+                result.push({ value: text, kind: 'text', captures: [] });
+                return;
+            }
+            const regex = regexes[regexIndex];
+            let currentIndex = 0;
+            let match;
+            regex.lastIndex = 0;
+            while ((match = regex.exec(text)) !== null) {
+                const stringBeforeMatch = text.substring(currentIndex, match.index);
+                if (stringBeforeMatch) {
+                    splitOne(stringBeforeMatch, regexIndex + 1);
+                }
+                const value = match[0];
+                result.push({
+                    value: value,
+                    kind: kinds[regexIndex],
+                    captures: match.slice(1)
+                });
+                currentIndex = match.index + value.length;
+            }
+            const stringAfterMatches = text.substring(currentIndex);
+            if (stringAfterMatches) {
+                splitOne(stringAfterMatches, regexIndex + 1);
+            }
+        };
+        splitOne(text, 0);
+        return result;
+    }
+};
+LinkDetector = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IOpenerService)),
+    ( __param(3, IPathService)),
+    ( __param(4, ITunnelService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IConfigurationService))
+], LinkDetector));
+
+export { LinkDetector };