@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/terminalContrib/links/browser/terminalExternalLinkDetector.js

@@ -0,0 +1,38 @@
+import { getXtermLineContent, convertLinkRangeToBuffer } from './terminalLinkHelpers.js';
+class TerminalExternalLinkDetector {
+    constructor(id, xterm, _provideLinks) {
+        this.id = id;
+        this.xterm = xterm;
+        this._provideLinks = _provideLinks;
+        this.maxLinkLength = 2000;
+    }
+    async detect(lines, startLine, endLine) {
+        const text = getXtermLineContent(this.xterm.buffer.active, startLine, endLine, this.xterm.cols);
+        if (text === '' || text.length > this.maxLinkLength) {
+            return [];
+        }
+        const externalLinks = await this._provideLinks(text);
+        if (!externalLinks) {
+            return [];
+        }
+        const result = ( externalLinks.map(link => {
+            const bufferRange = convertLinkRangeToBuffer(lines, this.xterm.cols, {
+                startColumn: link.startIndex + 1,
+                startLineNumber: 1,
+                endColumn: link.startIndex + link.length + 1,
+                endLineNumber: 1
+            }, startLine);
+            const matchingText = text.substring(link.startIndex, link.startIndex + link.length) || '';
+            const l = {
+                text: matchingText,
+                label: link.label,
+                bufferRange,
+                type: { id: this.id },
+                activate: link.activate
+            };
+            return l;
+        }));
+        return result;
+    }
+}
+export { TerminalExternalLinkDetector };

package/vscode/src/vs/workbench/contrib/terminalContrib/links/browser/terminalLink.js

@@ -0,0 +1,120 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { getWindow, addDisposableListener, EventType } from '../../../../../base/browser/dom.js';
+import { RunOnceScheduler } from '../../../../../base/common/async.js';
+import { convertBufferRangeToViewport } from './terminalLinkHelpers.js';
+import { isMacintosh } from '../../../../../base/common/platform.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+let TerminalLink = class TerminalLink extends DisposableStore {
+    get onInvalidated() { return this._onInvalidated.event; }
+    get type() { return this._type; }
+    constructor(_xterm, range, text, uri, parsedLink, actions, _viewportY, _activateCallback, _tooltipCallback, _isHighConfidenceLink, label, _type, _configurationService) {
+        super();
+        this._xterm = _xterm;
+        this.range = range;
+        this.text = text;
+        this.uri = uri;
+        this.parsedLink = parsedLink;
+        this.actions = actions;
+        this._viewportY = _viewportY;
+        this._activateCallback = _activateCallback;
+        this._tooltipCallback = _tooltipCallback;
+        this._isHighConfidenceLink = _isHighConfidenceLink;
+        this.label = label;
+        this._type = _type;
+        this._configurationService = _configurationService;
+        this._onInvalidated = ( new Emitter());
+        this.decorations = {
+            pointerCursor: false,
+            underline: this._isHighConfidenceLink
+        };
+    }
+    dispose() {
+        super.dispose();
+        this._hoverListeners?.dispose();
+        this._hoverListeners = undefined;
+        this._tooltipScheduler?.dispose();
+        this._tooltipScheduler = undefined;
+    }
+    activate(event, text) {
+        this.asyncActivate = this._activateCallback(event, text);
+    }
+    hover(event, text) {
+        const w = getWindow(event);
+        const d = w.document;
+        this._hoverListeners = ( new DisposableStore());
+        this._hoverListeners.add(addDisposableListener(d, 'keydown', e => {
+            if (!e.repeat && this._isModifierDown(e)) {
+                this._enableDecorations();
+            }
+        }));
+        this._hoverListeners.add(addDisposableListener(d, 'keyup', e => {
+            if (!e.repeat && !this._isModifierDown(e)) {
+                this._disableDecorations();
+            }
+        }));
+        this._hoverListeners.add(this._xterm.onRender(e => {
+            const viewportRangeY = this.range.start.y - this._viewportY;
+            if (viewportRangeY >= e.start && viewportRangeY <= e.end) {
+                this._onInvalidated.fire();
+            }
+        }));
+        if (this._isHighConfidenceLink) {
+            this._tooltipScheduler = ( new RunOnceScheduler(() => {
+                this._tooltipCallback(this, convertBufferRangeToViewport(this.range, this._viewportY), this._isHighConfidenceLink ? () => this._enableDecorations() : undefined, this._isHighConfidenceLink ? () => this._disableDecorations() : undefined);
+                this._tooltipScheduler?.dispose();
+                this._tooltipScheduler = undefined;
+            }, this._configurationService.getValue('workbench.hover.delay')));
+            this.add(this._tooltipScheduler);
+            this._tooltipScheduler.schedule();
+        }
+        const origin = { x: event.pageX, y: event.pageY };
+        this._hoverListeners.add(addDisposableListener(d, EventType.MOUSE_MOVE, e => {
+            if (this._isModifierDown(e)) {
+                this._enableDecorations();
+            }
+            else {
+                this._disableDecorations();
+            }
+            if (Math.abs(e.pageX - origin.x) > w.devicePixelRatio * 2 || Math.abs(e.pageY - origin.y) > w.devicePixelRatio * 2) {
+                origin.x = e.pageX;
+                origin.y = e.pageY;
+                this._tooltipScheduler?.schedule();
+            }
+        }));
+    }
+    leave() {
+        this._hoverListeners?.dispose();
+        this._hoverListeners = undefined;
+        this._tooltipScheduler?.dispose();
+        this._tooltipScheduler = undefined;
+    }
+    _enableDecorations() {
+        if (!this.decorations.pointerCursor) {
+            this.decorations.pointerCursor = true;
+        }
+        if (!this.decorations.underline) {
+            this.decorations.underline = true;
+        }
+    }
+    _disableDecorations() {
+        if (this.decorations.pointerCursor) {
+            this.decorations.pointerCursor = false;
+        }
+        if (this.decorations.underline !== this._isHighConfidenceLink) {
+            this.decorations.underline = this._isHighConfidenceLink;
+        }
+    }
+    _isModifierDown(event) {
+        const multiCursorModifier = this._configurationService.getValue('editor.multiCursorModifier');
+        if (multiCursorModifier === 'ctrlCmd') {
+            return !!event.altKey;
+        }
+        return isMacintosh ? event.metaKey : event.ctrlKey;
+    }
+};
+TerminalLink = ( __decorate([
+    ( __param(12, IConfigurationService))
+], TerminalLink));
+export { TerminalLink };

package/vscode/src/vs/workbench/contrib/terminalContrib/links/browser/terminalLinkDetectorAdapter.js

@@ -0,0 +1,108 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { TerminalLink } from './terminalLink.js';
+let TerminalLinkDetectorAdapter = class TerminalLinkDetectorAdapter extends Disposable {
+    constructor(_detector, _instantiationService) {
+        super();
+        this._detector = _detector;
+        this._instantiationService = _instantiationService;
+        this._onDidActivateLink = this._register(( new Emitter()));
+        this.onDidActivateLink = this._onDidActivateLink.event;
+        this._onDidShowHover = this._register(( new Emitter()));
+        this.onDidShowHover = this._onDidShowHover.event;
+        this._activeProvideLinkRequests = ( new Map());
+    }
+    async provideLinks(bufferLineNumber, callback) {
+        let activeRequest = this._activeProvideLinkRequests.get(bufferLineNumber);
+        if (activeRequest) {
+            await activeRequest;
+            callback(this._activeLinks);
+            return;
+        }
+        if (this._activeLinks) {
+            for (const link of this._activeLinks) {
+                link.dispose();
+            }
+        }
+        activeRequest = this._provideLinks(bufferLineNumber);
+        this._activeProvideLinkRequests.set(bufferLineNumber, activeRequest);
+        this._activeLinks = await activeRequest;
+        this._activeProvideLinkRequests.delete(bufferLineNumber);
+        callback(this._activeLinks);
+    }
+    async _provideLinks(bufferLineNumber) {
+        const links = [];
+        let startLine = bufferLineNumber - 1;
+        let endLine = startLine;
+        const lines = [
+            this._detector.xterm.buffer.active.getLine(startLine)
+        ];
+        const maxLineContext = Math.max(this._detector.maxLinkLength, this._detector.xterm.cols);
+        const minStartLine = Math.max(startLine - maxLineContext, 0);
+        const maxEndLine = Math.min(endLine + maxLineContext, this._detector.xterm.buffer.active.length);
+        while (startLine >= minStartLine && this._detector.xterm.buffer.active.getLine(startLine)?.isWrapped) {
+            lines.unshift(this._detector.xterm.buffer.active.getLine(startLine - 1));
+            startLine--;
+        }
+        while (endLine < maxEndLine && this._detector.xterm.buffer.active.getLine(endLine + 1)?.isWrapped) {
+            lines.push(this._detector.xterm.buffer.active.getLine(endLine + 1));
+            endLine++;
+        }
+        const detectedLinks = await this._detector.detect(lines, startLine, endLine);
+        for (const link of detectedLinks) {
+            links.push(this._createTerminalLink(link, async (event) => this._onDidActivateLink.fire({ link, event })));
+        }
+        return links;
+    }
+    _createTerminalLink(l, activateCallback) {
+        if (!l.disableTrimColon && l.text.length > 0 && l.text.charAt(l.text.length - 1) === ':') {
+            l.text = l.text.slice(0, -1);
+            l.bufferRange.end.x--;
+        }
+        return this._instantiationService.createInstance(TerminalLink, this._detector.xterm, l.bufferRange, l.text, l.uri, l.parsedLink, l.actions, this._detector.xterm.buffer.active.viewportY, activateCallback, (link, viewportRange, modifierDownCallback, modifierUpCallback) => this._onDidShowHover.fire({
+            link,
+            viewportRange,
+            modifierDownCallback,
+            modifierUpCallback
+        }), l.type !== "Search" ,
+        l.label || this._getLabel(l.type), l.type);
+    }
+    _getLabel(type) {
+        switch (type) {
+            case "Search" : return ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkDetectorAdapter',
+                'searchWorkspace',
+                'Search workspace'
+            ));
+            case "LocalFile" : return ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkDetectorAdapter',
+                'openFile',
+                'Open file in editor'
+            ));
+            case "LocalFolderInWorkspace" : return ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkDetectorAdapter',
+                'focusFolder',
+                'Focus folder in explorer'
+            ));
+            case "LocalFolderOutsideWorkspace" : return ( localizeWithPath(
+                'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkDetectorAdapter',
+                'openFolder',
+                'Open folder in new window'
+            ));
+            case "Url" :
+            default:
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkDetectorAdapter',
+                    'followLink',
+                    'Follow link'
+                ));
+        }
+    }
+};
+TerminalLinkDetectorAdapter = ( __decorate([
+    ( __param(1, IInstantiationService))
+], TerminalLinkDetectorAdapter));
+export { TerminalLinkDetectorAdapter };

package/vscode/src/vs/workbench/contrib/terminalContrib/links/browser/terminalLinkHelpers.js

@@ -0,0 +1,175 @@
+import { win32, posix } from '../../../../../base/common/path.js';
+function convertLinkRangeToBuffer(lines, bufferWidth, range, startLine) {
+    const bufferRange = {
+        start: {
+            x: range.startColumn,
+            y: range.startLineNumber + startLine
+        },
+        end: {
+            x: range.endColumn - 1,
+            y: range.endLineNumber + startLine
+        }
+    };
+    let startOffset = 0;
+    const startWrappedLineCount = Math.ceil(range.startColumn / bufferWidth);
+    for (let y = 0; y < Math.min(startWrappedLineCount); y++) {
+        const lineLength = Math.min(bufferWidth, (range.startColumn - 1) - y * bufferWidth);
+        let lineOffset = 0;
+        const line = lines[y];
+        if (!line) {
+            break;
+        }
+        for (let x = 0; x < Math.min(bufferWidth, lineLength + lineOffset); x++) {
+            const cell = line.getCell(x);
+            if (!cell) {
+                break;
+            }
+            const width = cell.getWidth();
+            if (width === 2) {
+                lineOffset++;
+            }
+            const char = cell.getChars();
+            if (char.length > 1) {
+                lineOffset -= char.length - 1;
+            }
+        }
+        startOffset += lineOffset;
+    }
+    let endOffset = 0;
+    const endWrappedLineCount = Math.ceil(range.endColumn / bufferWidth);
+    for (let y = Math.max(0, startWrappedLineCount - 1); y < endWrappedLineCount; y++) {
+        const start = (y === startWrappedLineCount - 1 ? (range.startColumn - 1 + startOffset) % bufferWidth : 0);
+        const lineLength = Math.min(bufferWidth, range.endColumn + startOffset - y * bufferWidth);
+        let lineOffset = 0;
+        const line = lines[y];
+        if (!line) {
+            break;
+        }
+        for (let x = start; x < Math.min(bufferWidth, lineLength + lineOffset); x++) {
+            const cell = line.getCell(x);
+            if (!cell) {
+                break;
+            }
+            const width = cell.getWidth();
+            const chars = cell.getChars();
+            if (width === 2) {
+                lineOffset++;
+            }
+            if (x === bufferWidth - 1 && chars === '') {
+                lineOffset++;
+            }
+            if (chars.length > 1) {
+                lineOffset -= chars.length - 1;
+            }
+        }
+        endOffset += lineOffset;
+    }
+    bufferRange.start.x += startOffset;
+    bufferRange.end.x += startOffset + endOffset;
+    while (bufferRange.start.x > bufferWidth) {
+        bufferRange.start.x -= bufferWidth;
+        bufferRange.start.y++;
+    }
+    while (bufferRange.end.x > bufferWidth) {
+        bufferRange.end.x -= bufferWidth;
+        bufferRange.end.y++;
+    }
+    return bufferRange;
+}
+function convertBufferRangeToViewport(bufferRange, viewportY) {
+    return {
+        start: {
+            x: bufferRange.start.x - 1,
+            y: bufferRange.start.y - viewportY - 1
+        },
+        end: {
+            x: bufferRange.end.x - 1,
+            y: bufferRange.end.y - viewportY - 1
+        }
+    };
+}
+function getXtermLineContent(buffer, lineStart, lineEnd, cols) {
+    const maxLineLength = Math.max(2048, cols * 2);
+    lineEnd = Math.min(lineEnd, lineStart + maxLineLength);
+    let content = '';
+    for (let i = lineStart; i <= lineEnd; i++) {
+        const line = buffer.getLine(i);
+        if (line) {
+            content += line.translateToString(true, 0, cols);
+        }
+    }
+    return content;
+}
+function getXtermRangesByAttr(buffer, lineStart, lineEnd, cols) {
+    let bufferRangeStart = undefined;
+    let lastFgAttr = -1;
+    let lastBgAttr = -1;
+    const ranges = [];
+    for (let y = lineStart; y <= lineEnd; y++) {
+        const line = buffer.getLine(y);
+        if (!line) {
+            continue;
+        }
+        for (let x = 0; x < cols; x++) {
+            const cell = line.getCell(x);
+            if (!cell) {
+                break;
+            }
+            const thisFgAttr = (cell.isBold() |
+                cell.isInverse() |
+                cell.isStrikethrough() |
+                cell.isUnderline());
+            const thisBgAttr = (cell.isDim() |
+                cell.isItalic());
+            if (lastFgAttr === -1 || lastBgAttr === -1) {
+                bufferRangeStart = { x, y };
+            }
+            else {
+                if (lastFgAttr !== thisFgAttr || lastBgAttr !== thisBgAttr) {
+                    const bufferRangeEnd = { x, y };
+                    ranges.push({
+                        start: bufferRangeStart,
+                        end: bufferRangeEnd
+                    });
+                    bufferRangeStart = { x, y };
+                }
+            }
+            lastFgAttr = thisFgAttr;
+            lastBgAttr = thisBgAttr;
+        }
+    }
+    return ranges;
+}
+function updateLinkWithRelativeCwd(capabilities, y, text, osPath, logService) {
+    const cwd = capabilities.get(2 )?.getCwdForLine(y);
+    logService.trace('terminalLinkHelpers#updateLinkWithRelativeCwd cwd', cwd);
+    if (!cwd) {
+        return undefined;
+    }
+    const result = [];
+    const sep = osPath.sep;
+    if (!text.includes(sep)) {
+        result.push(osPath.resolve(cwd + sep + text));
+    }
+    else {
+        let commonDirs = 0;
+        let i = 0;
+        const cwdPath = cwd.split(sep).reverse();
+        const linkPath = text.split(sep);
+        while (i < cwdPath.length) {
+            result.push(osPath.resolve(cwd + sep + linkPath.slice(commonDirs).join(sep)));
+            if (cwdPath[i] === linkPath[i]) {
+                commonDirs++;
+            }
+            else {
+                break;
+            }
+            i++;
+        }
+    }
+    return result;
+}
+function osPathModule(os) {
+    return os === 1  ? win32 : posix;
+}
+export { convertBufferRangeToViewport, convertLinkRangeToBuffer, getXtermLineContent, getXtermRangesByAttr, osPathModule, updateLinkWithRelativeCwd };