@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.1

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetection/terminalCommand.js

@@ -0,0 +1,257 @@
+class TerminalCommand {
+    get command() { return this._properties.command; }
+    get isTrusted() { return this._properties.isTrusted; }
+    get timestamp() { return this._properties.timestamp; }
+    get promptStartMarker() { return this._properties.promptStartMarker; }
+    get marker() { return this._properties.marker; }
+    get endMarker() { return this._properties.endMarker; }
+    set endMarker(value) { this._properties.endMarker = value; }
+    get executedMarker() { return this._properties.executedMarker; }
+    get aliases() { return this._properties.aliases; }
+    get wasReplayed() { return this._properties.wasReplayed; }
+    get cwd() { return this._properties.cwd; }
+    get exitCode() { return this._properties.exitCode; }
+    get commandStartLineContent() { return this._properties.commandStartLineContent; }
+    get markProperties() { return this._properties.markProperties; }
+    get executedX() { return this._properties.executedX; }
+    get startX() { return this._properties.startX; }
+    constructor(_xterm, _properties) {
+        this._xterm = _xterm;
+        this._properties = _properties;
+    }
+    static deserialize(xterm, serialized, isCommandStorageDisabled) {
+        const buffer = xterm.buffer.normal;
+        const marker = serialized.startLine !== undefined ? xterm.registerMarker(serialized.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
+        if (!marker) {
+            return undefined;
+        }
+        const promptStartMarker = serialized.promptStartLine !== undefined ? xterm.registerMarker(serialized.promptStartLine - (buffer.baseY + buffer.cursorY)) : undefined;
+        const endMarker = serialized.endLine !== undefined ? xterm.registerMarker(serialized.endLine - (buffer.baseY + buffer.cursorY)) : undefined;
+        const executedMarker = serialized.executedLine !== undefined ? xterm.registerMarker(serialized.executedLine - (buffer.baseY + buffer.cursorY)) : undefined;
+        const newCommand = ( new TerminalCommand(xterm, {
+            command: isCommandStorageDisabled ? '' : serialized.command,
+            isTrusted: serialized.isTrusted,
+            promptStartMarker,
+            marker,
+            startX: serialized.startX,
+            endMarker,
+            executedMarker,
+            executedX: serialized.executedX,
+            timestamp: serialized.timestamp,
+            cwd: serialized.cwd,
+            commandStartLineContent: serialized.commandStartLineContent,
+            exitCode: serialized.exitCode,
+            markProperties: serialized.markProperties,
+            aliases: undefined,
+            wasReplayed: true
+        }));
+        return newCommand;
+    }
+    serialize(isCommandStorageDisabled) {
+        return {
+            promptStartLine: this.promptStartMarker?.line,
+            startLine: this.marker?.line,
+            startX: undefined,
+            endLine: this.endMarker?.line,
+            executedLine: this.executedMarker?.line,
+            executedX: this.executedX,
+            command: isCommandStorageDisabled ? '' : this.command,
+            isTrusted: this.isTrusted,
+            cwd: this.cwd,
+            exitCode: this.exitCode,
+            commandStartLineContent: this.commandStartLineContent,
+            timestamp: this.timestamp,
+            markProperties: this.markProperties,
+        };
+    }
+    getOutput() {
+        if (!this.executedMarker || !this.endMarker) {
+            return undefined;
+        }
+        const startLine = this.executedMarker.line;
+        const endLine = this.endMarker.line;
+        if (startLine === endLine) {
+            return undefined;
+        }
+        let output = '';
+        let line;
+        for (let i = startLine; i < endLine; i++) {
+            line = this._xterm.buffer.active.getLine(i);
+            if (!line) {
+                continue;
+            }
+            output += line.translateToString(!line.isWrapped) + (line.isWrapped ? '' : '\n');
+        }
+        return output === '' ? undefined : output;
+    }
+    getOutputMatch(outputMatcher) {
+        if (!this.executedMarker || !this.endMarker) {
+            return undefined;
+        }
+        const endLine = this.endMarker.line;
+        if (endLine === -1) {
+            return undefined;
+        }
+        const buffer = this._xterm.buffer.active;
+        const startLine = Math.max(this.executedMarker.line, 0);
+        const matcher = outputMatcher.lineMatcher;
+        const linesToCheck = typeof matcher === 'string' ? 1 : outputMatcher.length || countNewLines(matcher);
+        const lines = [];
+        let match;
+        if (outputMatcher.anchor === 'bottom') {
+            for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
+                let wrappedLineStart = i;
+                const wrappedLineEnd = i;
+                while (wrappedLineStart >= startLine && buffer.getLine(wrappedLineStart)?.isWrapped) {
+                    wrappedLineStart--;
+                }
+                i = wrappedLineStart;
+                lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, this._xterm.cols));
+                if (!match) {
+                    match = lines[0].match(matcher);
+                }
+                if (lines.length >= linesToCheck) {
+                    break;
+                }
+            }
+        }
+        else {
+            for (let i = startLine + (outputMatcher.offset || 0); i < endLine; i++) {
+                const wrappedLineStart = i;
+                let wrappedLineEnd = i;
+                while (wrappedLineEnd + 1 < endLine && buffer.getLine(wrappedLineEnd + 1)?.isWrapped) {
+                    wrappedLineEnd++;
+                }
+                i = wrappedLineEnd;
+                lines.push(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, this._xterm.cols));
+                if (!match) {
+                    match = lines[lines.length - 1].match(matcher);
+                }
+                if (lines.length >= linesToCheck) {
+                    break;
+                }
+            }
+        }
+        return match ? { regexMatch: match, outputLines: lines } : undefined;
+    }
+    hasOutput() {
+        return (!this.executedMarker?.isDisposed &&
+            !this.endMarker?.isDisposed &&
+            !!(this.executedMarker &&
+                this.endMarker &&
+                this.executedMarker.line < this.endMarker.line));
+    }
+    getPromptRowCount() {
+        return getPromptRowCount(this, this._xterm.buffer.active);
+    }
+    getCommandRowCount() {
+        return getCommandRowCount(this);
+    }
+}
+class PartialTerminalCommand {
+    constructor(_xterm) {
+        this._xterm = _xterm;
+    }
+    serialize(cwd) {
+        if (!this.commandStartMarker) {
+            return undefined;
+        }
+        return {
+            promptStartLine: this.promptStartMarker?.line,
+            startLine: this.commandStartMarker.line,
+            startX: this.commandStartX,
+            endLine: undefined,
+            executedLine: undefined,
+            executedX: undefined,
+            command: '',
+            isTrusted: true,
+            cwd,
+            exitCode: undefined,
+            commandStartLineContent: undefined,
+            timestamp: 0,
+            markProperties: undefined
+        };
+    }
+    promoteToFullCommand(cwd, exitCode, ignoreCommandLine, markProperties) {
+        if (exitCode === undefined && this.command === undefined) {
+            this.command = '';
+        }
+        if ((this.command !== undefined && !this.command.startsWith('\\')) || ignoreCommandLine) {
+            return ( new TerminalCommand(this._xterm, {
+                command: ignoreCommandLine ? '' : (this.command || ''),
+                isTrusted: !!this.isTrusted,
+                promptStartMarker: this.promptStartMarker,
+                marker: this.commandStartMarker,
+                startX: this.commandStartX,
+                endMarker: this.commandFinishedMarker,
+                executedMarker: this.commandExecutedMarker,
+                executedX: this.commandExecutedX,
+                timestamp: Date.now(),
+                cwd,
+                exitCode,
+                commandStartLineContent: this.commandStartLineContent,
+                markProperties
+            }));
+        }
+        return undefined;
+    }
+    getPromptRowCount() {
+        return getPromptRowCount(this, this._xterm.buffer.active);
+    }
+    getCommandRowCount() {
+        return getCommandRowCount(this);
+    }
+}
+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 countNewLines(regex) {
+    if (!regex.multiline) {
+        return 1;
+    }
+    const source = regex.source;
+    let count = 1;
+    let i = source.indexOf('\\n');
+    while (i !== -1) {
+        count++;
+        i = source.indexOf('\\n', i + 1);
+    }
+    return count;
+}
+function getPromptRowCount(command, buffer) {
+    const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
+    if (!marker || !command.promptStartMarker) {
+        return 1;
+    }
+    let promptRowCount = 1;
+    let promptStartLine = command.promptStartMarker.line;
+    while (promptStartLine < marker.line && (buffer.getLine(promptStartLine)?.translateToString(true) ?? '').length === 0) {
+        promptStartLine++;
+    }
+    promptRowCount = marker.line - promptStartLine + 1;
+    return promptRowCount;
+}
+function getCommandRowCount(command) {
+    const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
+    const executedMarker = 'hasOutput' in command ? command.executedMarker : command.commandExecutedMarker;
+    if (!marker || !executedMarker) {
+        return 1;
+    }
+    const commandExecutedLine = Math.max(executedMarker.line, marker.line);
+    let commandRowCount = commandExecutedLine - marker.line + 1;
+    const executedX = 'hasOutput' in command ? command.executedX : command.commandExecutedX;
+    if (executedX === 0) {
+        commandRowCount--;
+    }
+    return commandRowCount;
+}
+export { PartialTerminalCommand, TerminalCommand };