@codingame/monaco-vscode-api 1.83.15-next.0 → 1.83.16

package/vscode/src/vs/platform/terminal/common/capabilities/terminalCapabilityStore.js

@@ -0,0 +1,94 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class TerminalCapabilityStore extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._map = ( new Map());
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return ( this._map.keys());
+    }
+    add(capability, impl) {
+        this._map.set(capability, impl);
+        this._onDidAddCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
+    }
+    get(capability) {
+        return this._map.get(capability);
+    }
+    remove(capability) {
+        const impl = this._map.get(capability);
+        if (!impl) {
+            return;
+        }
+        this._map.delete(capability);
+        this._onDidRemoveCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
+    }
+    has(capability) {
+        return ( this._map.has(capability));
+    }
+}
+class TerminalCapabilityStoreMultiplexer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._stores = [];
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return this._items();
+    }
+    *_items() {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                yield c;
+            }
+        }
+    }
+    has(capability) {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                if (c === capability) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    get(capability) {
+        for (const store of this._stores) {
+            const c = store.get(capability);
+            if (c) {
+                return c;
+            }
+        }
+        return undefined;
+    }
+    add(store) {
+        this._stores.push(store);
+        for (const capability of store.items) {
+            this._onDidAddCapabilityType.fire(capability);
+            this._onDidAddCapability.fire({ id: capability, capability: store.get(capability) });
+        }
+        this._register(store.onDidAddCapabilityType(e => this._onDidAddCapabilityType.fire(e)));
+        this._register(store.onDidAddCapability(e => this._onDidAddCapability.fire(e)));
+        this._register(store.onDidRemoveCapabilityType(e => this._onDidRemoveCapabilityType.fire(e)));
+        this._register(store.onDidRemoveCapability(e => this._onDidRemoveCapability.fire(e)));
+    }
+}
+export { TerminalCapabilityStore, TerminalCapabilityStoreMultiplexer };

package/vscode/src/vs/platform/terminal/common/terminalEnvironment.js

@@ -0,0 +1,37 @@
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+function escapeNonWindowsPath(path) {
+    let newPath = path;
+    if (newPath.includes('\\')) {
+        newPath = newPath.replace(/\\/g, '\\\\');
+    }
+    const bannedChars = /[\`\$\|\&\>\~\#\!\^\*\;\<\"\']/g;
+    newPath = newPath.replace(bannedChars, '');
+    return `'${newPath}'`;
+}
+function collapseTildePath(path, userHome, separator) {
+    if (!path) {
+        return '';
+    }
+    if (!userHome) {
+        return path;
+    }
+    if (userHome.match(/[\/\\]$/)) {
+        userHome = userHome.slice(0, userHome.length - 1);
+    }
+    const normalizedPath = path.replace(/\\/g, '/').toLowerCase();
+    const normalizedUserHome = userHome.replace(/\\/g, '/').toLowerCase();
+    if (!normalizedPath.includes(normalizedUserHome)) {
+        return path;
+    }
+    return `~${separator}${path.slice(userHome.length + 1)}`;
+}
+function sanitizeCwd(cwd) {
+    if (cwd.match(/^['"].*['"]$/)) {
+        cwd = cwd.substring(1, cwd.length - 1);
+    }
+    if (OS === 1  && cwd && cwd[1] === ':') {
+        return cwd[0].toUpperCase() + cwd.substring(1);
+    }
+    return cwd;
+}
+export { collapseTildePath, escapeNonWindowsPath, sanitizeCwd };

package/vscode/src/vs/platform/terminal/common/terminalStrings.js

@@ -0,0 +1,16 @@
+function formatMessageForTerminal(message, options = {}) {
+    let result = '';
+    if (!options.excludeLeadingNewLine) {
+        result += '\r\n';
+    }
+    result += '\x1b[0m\x1b[7m * ';
+    if (options.loudFormatting) {
+        result += '\x1b[0;104m';
+    }
+    else {
+        result += '\x1b[0m';
+    }
+    result += ` ${message} \x1b[0m\n\r`;
+    return result;
+}
+export { formatMessageForTerminal };

package/vscode/src/vs/platform/terminal/common/xterm/shellIntegrationAddon.js

@@ -0,0 +1,319 @@
+import { Disposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { TerminalCapabilityStore } from '../capabilities/terminalCapabilityStore.js';
+import { CommandDetectionCapability } from '../capabilities/commandDetectionCapability.js';
+import { CwdDetectionCapability } from '../capabilities/cwdDetectionCapability.js';
+import { PartialCommandDetectionCapability } from '../capabilities/partialCommandDetectionCapability.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { BufferMarkCapability } from '../capabilities/bufferMarkCapability.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { sanitizeCwd } from '../terminalEnvironment.js';
+class ShellIntegrationAddon extends Disposable {
+    get status() { return this._status; }
+    constructor(_nonce, _disableTelemetry, _telemetryService, _logService) {
+        super();
+        this._nonce = _nonce;
+        this._disableTelemetry = _disableTelemetry;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this.capabilities = this._register(( new TerminalCapabilityStore()));
+        this._hasUpdatedTelemetry = false;
+        this._commonProtocolDisposables = [];
+        this._status = 0 ;
+        this._onDidChangeStatus = ( new Emitter());
+        this.onDidChangeStatus = this._onDidChangeStatus.event;
+        this._register(toDisposable(() => {
+            this._clearActivationTimeout();
+            this._disposeCommonProtocol();
+        }));
+    }
+    _disposeCommonProtocol() {
+        dispose(this._commonProtocolDisposables);
+        this._commonProtocolDisposables.length = 0;
+    }
+    activate(xterm) {
+        this._terminal = xterm;
+        this.capabilities.add(3 , this._register(( new PartialCommandDetectionCapability(this._terminal))));
+        this._register(xterm.parser.registerOscHandler(633 , data => this._handleVSCodeSequence(data)));
+        this._register(xterm.parser.registerOscHandler(1337 , data => this._doHandleITermSequence(data)));
+        this._commonProtocolDisposables.push(xterm.parser.registerOscHandler(133 , data => this._handleFinalTermSequence(data)));
+        this._register(xterm.parser.registerOscHandler(7 , data => this._doHandleSetCwd(data)));
+        this._register(xterm.parser.registerOscHandler(9 , data => this._doHandleSetWindowsFriendlyCwd(data)));
+        this._ensureCapabilitiesOrAddFailureTelemetry();
+    }
+    getMarkerId(terminal, vscodeMarkerId) {
+        this._createOrGetBufferMarkDetection(terminal).getMark(vscodeMarkerId);
+    }
+    _handleFinalTermSequence(data) {
+        const didHandle = this._doHandleFinalTermSequence(data);
+        if (this._status === 0 ) {
+            this._status = 1 ;
+            this._onDidChangeStatus.fire(this._status);
+        }
+        return didHandle;
+    }
+    _doHandleFinalTermSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command, ...args] = data.split(';');
+        switch (command) {
+            case 'A':
+                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
+                return true;
+            case 'B':
+                this._createOrGetCommandDetection(this._terminal).handleCommandStart({ ignoreCommandLine: true });
+                return true;
+            case 'C':
+                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
+                return true;
+            case 'D': {
+                const exitCode = args.length === 1 ? parseInt(args[0]) : undefined;
+                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
+                return true;
+            }
+        }
+        return false;
+    }
+    _handleVSCodeSequence(data) {
+        const didHandle = this._doHandleVSCodeSequence(data);
+        if (!this._hasUpdatedTelemetry && didHandle) {
+            this._telemetryService?.publicLog2('terminal/shellIntegrationActivationSucceeded');
+            this._hasUpdatedTelemetry = true;
+            this._clearActivationTimeout();
+        }
+        if (this._status !== 2 ) {
+            this._status = 2 ;
+            this._onDidChangeStatus.fire(this._status);
+        }
+        return didHandle;
+    }
+    async _ensureCapabilitiesOrAddFailureTelemetry() {
+        if (!this._telemetryService || this._disableTelemetry) {
+            return;
+        }
+        this._activationTimeout = setTimeout(() => {
+            if (!this.capabilities.get(2 ) && !this.capabilities.get(0 )) {
+                this._telemetryService?.publicLog2('terminal/shellIntegrationActivationTimeout');
+                this._logService.warn('Shell integration failed to add capabilities within 10 seconds');
+            }
+            this._hasUpdatedTelemetry = true;
+        }, 10000);
+    }
+    _clearActivationTimeout() {
+        if (this._activationTimeout !== undefined) {
+            clearTimeout(this._activationTimeout);
+            this._activationTimeout = undefined;
+        }
+    }
+    _doHandleVSCodeSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const argsIndex = data.indexOf(';');
+        const sequenceCommand = argsIndex === -1 ? data : data.substring(0, argsIndex);
+        const args = argsIndex === -1 ? [] : data.substring(argsIndex + 1).split(';');
+        switch (sequenceCommand) {
+            case "A" :
+                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
+                return true;
+            case "B" :
+                this._createOrGetCommandDetection(this._terminal).handleCommandStart();
+                return true;
+            case "C" :
+                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
+                return true;
+            case "D" : {
+                const arg0 = args[0];
+                const exitCode = arg0 !== undefined ? parseInt(arg0) : undefined;
+                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
+                return true;
+            }
+            case "E" : {
+                const arg0 = args[0];
+                const arg1 = args[1];
+                let commandLine;
+                if (arg0 !== undefined) {
+                    commandLine = deserializeMessage(arg0);
+                }
+                else {
+                    commandLine = '';
+                }
+                this._createOrGetCommandDetection(this._terminal).setCommandLine(commandLine, arg1 === this._nonce);
+                return true;
+            }
+            case "F" : {
+                this._createOrGetCommandDetection(this._terminal).handleContinuationStart();
+                return true;
+            }
+            case "G" : {
+                this._createOrGetCommandDetection(this._terminal).handleContinuationEnd();
+                return true;
+            }
+            case "H" : {
+                this._createOrGetCommandDetection(this._terminal).handleRightPromptStart();
+                return true;
+            }
+            case "I" : {
+                this._createOrGetCommandDetection(this._terminal).handleRightPromptEnd();
+                return true;
+            }
+            case "P" : {
+                const arg0 = args[0];
+                const deserialized = arg0 !== undefined ? deserializeMessage(arg0) : '';
+                const { key, value } = parseKeyValueAssignment(deserialized);
+                if (value === undefined) {
+                    return true;
+                }
+                switch (key) {
+                    case 'Cwd': {
+                        this._updateCwd(value);
+                        return true;
+                    }
+                    case 'IsWindows': {
+                        this._createOrGetCommandDetection(this._terminal).setIsWindowsPty(value === 'True' ? true : false);
+                        return true;
+                    }
+                    case 'Task': {
+                        this._createOrGetBufferMarkDetection(this._terminal);
+                        this.capabilities.get(2 )?.setIsCommandStorageDisabled();
+                        return true;
+                    }
+                }
+            }
+            case "SetMark" : {
+                this._createOrGetBufferMarkDetection(this._terminal).addMark(parseMarkSequence(args));
+                return true;
+            }
+        }
+        return false;
+    }
+    _updateCwd(value) {
+        value = sanitizeCwd(value);
+        this._createOrGetCwdDetection().updateCwd(value);
+        const commandDetection = this.capabilities.get(2 );
+        commandDetection?.setCwd(value);
+    }
+    _doHandleITermSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command] = data.split(';');
+        switch (command) {
+            case "SetMark" : {
+                this._createOrGetBufferMarkDetection(this._terminal).addMark();
+            }
+            default: {
+                const { key, value } = parseKeyValueAssignment(command);
+                if (value === undefined) {
+                    return true;
+                }
+                switch (key) {
+                    case "CurrentDir" :
+                        this._updateCwd(value);
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    _doHandleSetWindowsFriendlyCwd(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command, ...args] = data.split(';');
+        switch (command) {
+            case '9':
+                if (args.length) {
+                    this._updateCwd(args[0]);
+                }
+                return true;
+        }
+        return false;
+    }
+    _doHandleSetCwd(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command] = data.split(';');
+        if (command.match(/^file:\/\/.*\//)) {
+            const uri = ( URI.parse(command));
+            if (uri.path && uri.path.length > 0) {
+                this._updateCwd(uri.path);
+                return true;
+            }
+        }
+        return false;
+    }
+    serialize() {
+        if (!this._terminal || !( this.capabilities.has(2 ))) {
+            return {
+                isWindowsPty: false,
+                commands: []
+            };
+        }
+        const result = this._createOrGetCommandDetection(this._terminal).serialize();
+        return result;
+    }
+    deserialize(serialized) {
+        if (!this._terminal) {
+            throw new Error('Cannot restore commands before addon is activated');
+        }
+        this._createOrGetCommandDetection(this._terminal).deserialize(serialized);
+    }
+    _createOrGetCwdDetection() {
+        let cwdDetection = this.capabilities.get(0 );
+        if (!cwdDetection) {
+            cwdDetection = this._register(( new CwdDetectionCapability()));
+            this.capabilities.add(0 , cwdDetection);
+        }
+        return cwdDetection;
+    }
+    _createOrGetCommandDetection(terminal) {
+        let commandDetection = this.capabilities.get(2 );
+        if (!commandDetection) {
+            commandDetection = this._register(( new CommandDetectionCapability(terminal, this._logService)));
+            this.capabilities.add(2 , commandDetection);
+        }
+        return commandDetection;
+    }
+    _createOrGetBufferMarkDetection(terminal) {
+        let bufferMarkDetection = this.capabilities.get(4 );
+        if (!bufferMarkDetection) {
+            bufferMarkDetection = this._register(( new BufferMarkCapability(terminal)));
+            this.capabilities.add(4 , bufferMarkDetection);
+        }
+        return bufferMarkDetection;
+    }
+}
+function deserializeMessage(message) {
+    return message.replaceAll(
+    /\\(\\|x([0-9a-f]{2}))/gi,
+    (_match, op, hex) => hex ? String.fromCharCode(parseInt(hex, 16)) : op);
+}
+function parseKeyValueAssignment(message) {
+    const separatorIndex = message.indexOf('=');
+    if (separatorIndex === -1) {
+        return { key: message, value: undefined };
+    }
+    return {
+        key: message.substring(0, separatorIndex),
+        value: message.substring(1 + separatorIndex)
+    };
+}
+function parseMarkSequence(sequence) {
+    let id = undefined;
+    let hidden = false;
+    for (const property of sequence) {
+        if (property === undefined) {
+            continue;
+        }
+        if (property === 'Hidden') {
+            hidden = true;
+        }
+        if (property.startsWith('Id=')) {
+            id = property.substring(3);
+        }
+    }
+    return { id, hidden };
+}
+export { ShellIntegrationAddon, deserializeMessage, parseKeyValueAssignment, parseMarkSequence };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/suggestEnabledInput/suggestEnabledInput.js

@@ -23,6 +23,8 @@ import { getSimpleEditorOptions } from '../simpleEditorOptions.js';
 import { SelectionClipboardContributionID } from '../selectionClipboard.js';
 import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { DEFAULT_FONT_FAMILY } from '../../../../browser/style.js';
+import { HistoryNavigator } from 'monaco-editor/esm/vs/base/common/history.js';
+import { registerAndCreateHistoryNavigationContext } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
 import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
 import { ensureValidWordDefinition, getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
@@ -206,6 +208,94 @@ SuggestEnabledInput = ( (__decorate([
     ( (__param(9, ILanguageFeaturesService))),
     ( (__param(10, IConfigurationService)))
 ], SuggestEnabledInput)));
+let SuggestEnabledInputWithHistory = class SuggestEnabledInputWithHistory extends SuggestEnabledInput {
+    constructor({ id, parent, ariaLabel, suggestionProvider, resourceHandle, suggestOptions, history }, instantiationService, modelService, contextKeyService, languageFeaturesService, configurationService) {
+        super(id, parent, suggestionProvider, ariaLabel, resourceHandle, suggestOptions, instantiationService, modelService, contextKeyService, languageFeaturesService, configurationService);
+        this.history = ( (new HistoryNavigator(history, 100)));
+    }
+    addToHistory() {
+        const value = this.getValue();
+        if (value && value !== this.getCurrentValue()) {
+            this.history.add(value);
+        }
+    }
+    getHistory() {
+        return this.history.getHistory();
+    }
+    showNextValue() {
+        if (!( (this.history.has(this.getValue())))) {
+            this.addToHistory();
+        }
+        let next = this.getNextValue();
+        if (next) {
+            next = next === this.getValue() ? this.getNextValue() : next;
+        }
+        this.setValue(next ?? '');
+    }
+    showPreviousValue() {
+        if (!( (this.history.has(this.getValue())))) {
+            this.addToHistory();
+        }
+        let previous = this.getPreviousValue();
+        if (previous) {
+            previous = previous === this.getValue() ? this.getPreviousValue() : previous;
+        }
+        if (previous) {
+            this.setValue(previous);
+            this.inputWidget.setPosition({ lineNumber: 0, column: 0 });
+        }
+    }
+    clearHistory() {
+        this.history.clear();
+    }
+    getCurrentValue() {
+        let currentValue = this.history.current();
+        if (!currentValue) {
+            currentValue = this.history.last();
+            this.history.next();
+        }
+        return currentValue;
+    }
+    getPreviousValue() {
+        return this.history.previous() || this.history.first();
+    }
+    getNextValue() {
+        return this.history.next();
+    }
+};
+SuggestEnabledInputWithHistory = ( (__decorate([
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IModelService))),
+    ( (__param(3, IContextKeyService))),
+    ( (__param(4, ILanguageFeaturesService))),
+    ( (__param(5, IConfigurationService)))
+], SuggestEnabledInputWithHistory)));
+let ContextScopedSuggestEnabledInputWithHistory = class ContextScopedSuggestEnabledInputWithHistory extends SuggestEnabledInputWithHistory {
+    constructor(options, instantiationService, modelService, contextKeyService, languageFeaturesService, configurationService) {
+        super(options, instantiationService, modelService, contextKeyService, languageFeaturesService, configurationService);
+        const { historyNavigationBackwardsEnablement, historyNavigationForwardsEnablement } = this.historyContext;
+        this._register(this.inputWidget.onDidChangeCursorPosition(({ position }) => {
+            const viewModel = this.inputWidget._getViewModel();
+            const lastLineNumber = viewModel.getLineCount();
+            const lastLineCol = viewModel.getLineLength(lastLineNumber) + 1;
+            const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(position);
+            historyNavigationBackwardsEnablement.set(viewPosition.lineNumber === 1 && viewPosition.column === 1);
+            historyNavigationForwardsEnablement.set(viewPosition.lineNumber === lastLineNumber && viewPosition.column === lastLineCol);
+        }));
+    }
+    getScopedContextKeyService(contextKeyService) {
+        const scopedContextKeyService = this._register(contextKeyService.createScoped(this.element));
+        this.historyContext = this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this));
+        return scopedContextKeyService;
+    }
+};
+ContextScopedSuggestEnabledInputWithHistory = ( (__decorate([
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IModelService))),
+    ( (__param(3, IContextKeyService))),
+    ( (__param(4, ILanguageFeaturesService))),
+    ( (__param(5, IConfigurationService)))
+], ContextScopedSuggestEnabledInputWithHistory)));
 registerThemingParticipant((theme, collector) => {
     const selectionBackgroundColor = theme.getColor(selectionBackground);
     if (selectionBackgroundColor) {
@@ -245,4 +335,4 @@ function getSuggestEnabledInputOptions(ariaLabel) {
         autoClosingBrackets: 'never'
     };
 }
-export { SuggestEnabledInput };
+export { ContextScopedSuggestEnabledInputWithHistory, SuggestEnabledInput, SuggestEnabledInputWithHistory };