@codingame/monaco-vscode-api 1.83.15 → 1.83.16

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/suggestAddon.js

@@ -0,0 +1,390 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { SimpleCompletionItem } from '../../../../services/suggest/browser/simpleCompletionItem.js';
+import { LineContext, SimpleCompletionModel } from '../../../../services/suggest/browser/simpleCompletionModel.js';
+import { SimpleSuggestWidget } from '../../../../services/suggest/browser/simpleSuggestWidget.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { editorSuggestWidgetSelectedBackground } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggestWidget.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { activeContrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { getListStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+const pwshTypeToIconMap = {
+    0: Codicon.symbolText,
+    1: Codicon.history,
+    2: Codicon.symbolMethod,
+    3: Codicon.symbolFile,
+    4: Codicon.folder,
+    5: Codicon.symbolProperty,
+    6: Codicon.symbolMethod,
+    7: Codicon.symbolVariable,
+    8: Codicon.symbolValue,
+    9: Codicon.symbolVariable,
+    10: Codicon.symbolNamespace,
+    11: Codicon.symbolInterface,
+    12: Codicon.symbolKeyword,
+    13: Codicon.symbolKeyword
+};
+let SuggestAddon = class SuggestAddon extends Disposable {
+    constructor(_terminalSuggestWidgetVisibleContextKey, _instantiationService) {
+        super();
+        this._terminalSuggestWidgetVisibleContextKey = _terminalSuggestWidgetVisibleContextKey;
+        this._instantiationService = _instantiationService;
+        this._enableWidget = true;
+        this._cursorIndexStart = 0;
+        this._cursorIndexDelta = 0;
+        this._onBell = this._register(( new Emitter()));
+        this.onBell = this._onBell.event;
+        this._onAcceptedCompletion = this._register(( new Emitter()));
+        this.onAcceptedCompletion = this._onAcceptedCompletion.event;
+        this._cachedBashAliases = ( new Set());
+        this._cachedBashBuiltins = ( new Set());
+        this._cachedBashCommands = ( new Set());
+        this._cachedBashKeywords = ( new Set());
+    }
+    activate(xterm) {
+        this._terminal = xterm;
+        this._register(xterm.parser.registerOscHandler(633 , data => {
+            return this._handleVSCodeSequence(data);
+        }));
+        this._register(xterm.onData(e => {
+            this._handleTerminalInput(e);
+        }));
+    }
+    setContainer(container) {
+        this._container = container;
+    }
+    _handleVSCodeSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command, ...args] = data.split(';');
+        switch (command) {
+            case "Completions" :
+                this._handleCompletionsSequence(this._terminal, data, command, args);
+                return true;
+            case "CompletionsBash" :
+                this._handleCompletionsBashSequence(this._terminal, data, command, args);
+                return true;
+            case "CompletionsBashFirstWord" :
+                return this._handleCompletionsBashFirstWordSequence(this._terminal, data, command, args);
+        }
+        return false;
+    }
+    _handleCompletionsSequence(terminal, data, command, args) {
+        if (!terminal.element || !this._enableWidget) {
+            return;
+        }
+        const replacementIndex = parseInt(args[0]);
+        const replacementLength = parseInt(args[1]);
+        this._cursorIndexStart = parseInt(args[2]);
+        if (!args[3]) {
+            this._onBell.fire();
+            return;
+        }
+        let completionList = JSON.parse(data.slice(command.length + args[0].length + args[1].length + args[2].length + 4 ));
+        if (!Array.isArray(completionList)) {
+            completionList = [completionList];
+        }
+        const completions = ( completionList.map((e) => {
+            return ( new SimpleCompletionItem({
+                label: e.CompletionText,
+                icon: pwshTypeToIconMap[e.ResultType],
+                detail: e.ToolTip
+            }));
+        }));
+        this._leadingLineContent = completions[0].completion.label.slice(0, replacementLength);
+        this._cursorIndexDelta = 0;
+        const model = ( new SimpleCompletionModel(completions, ( new LineContext(this._leadingLineContent, replacementIndex)), replacementIndex, replacementLength));
+        if (completions.length === 1) {
+            const insertText = completions[0].completion.label.substring(replacementLength);
+            if (insertText.length === 0) {
+                this._onBell.fire();
+                return;
+            }
+        }
+        this._handleCompletionModel(model);
+    }
+    _handleCompletionsBashFirstWordSequence(terminal, data, command, args) {
+        const type = args[0];
+        const completionList = data.slice(command.length + type.length + 2 ).split(';');
+        let set;
+        switch (type) {
+            case 'alias':
+                set = this._cachedBashAliases;
+                break;
+            case 'builtin':
+                set = this._cachedBashBuiltins;
+                break;
+            case 'command':
+                set = this._cachedBashCommands;
+                break;
+            case 'keyword':
+                set = this._cachedBashKeywords;
+                break;
+            default: return false;
+        }
+        set.clear();
+        const distinctLabels = ( new Set());
+        for (const label of completionList) {
+            distinctLabels.add(label);
+        }
+        for (const label of distinctLabels) {
+            set.add(( new SimpleCompletionItem({
+                label,
+                icon: Codicon.symbolString,
+                detail: type
+            })));
+        }
+        this._cachedFirstWord = undefined;
+        return true;
+    }
+    _handleCompletionsBashSequence(terminal, data, command, args) {
+        if (!terminal.element) {
+            return;
+        }
+        let replacementIndex = parseInt(args[0]);
+        const replacementLength = parseInt(args[1]);
+        if (!args[2]) {
+            this._onBell.fire();
+            return;
+        }
+        const completionList = data.slice(command.length + args[0].length + args[1].length + args[2].length + 4 ).split(';');
+        let completions;
+        if (replacementIndex !== 100 && completionList.length > 0) {
+            completions = ( completionList.map(label => {
+                return ( new SimpleCompletionItem({
+                    label: label,
+                    icon: Codicon.symbolProperty
+                }));
+            }));
+        }
+        else {
+            replacementIndex = 0;
+            if (!this._cachedFirstWord) {
+                this._cachedFirstWord = [
+                    ...this._cachedBashAliases,
+                    ...this._cachedBashBuiltins,
+                    ...this._cachedBashCommands,
+                    ...this._cachedBashKeywords
+                ];
+                this._cachedFirstWord.sort((a, b) => {
+                    const aCode = a.completion.label.charCodeAt(0);
+                    const bCode = b.completion.label.charCodeAt(0);
+                    const isANonAlpha = aCode < 65 || aCode > 90 && aCode < 97 || aCode > 122 ? 1 : 0;
+                    const isBNonAlpha = bCode < 65 || bCode > 90 && bCode < 97 || bCode > 122 ? 1 : 0;
+                    if (isANonAlpha !== isBNonAlpha) {
+                        return isANonAlpha - isBNonAlpha;
+                    }
+                    return a.completion.label.localeCompare(b.completion.label);
+                });
+            }
+            completions = this._cachedFirstWord;
+        }
+        if (completions.length === 0) {
+            return;
+        }
+        this._leadingLineContent = completions[0].completion.label.slice(0, replacementLength);
+        const model = ( new SimpleCompletionModel(completions, ( new LineContext(this._leadingLineContent, replacementIndex)), replacementIndex, replacementLength));
+        if (completions.length === 1) {
+            const insertText = completions[0].completion.label.substring(replacementLength);
+            if (insertText.length === 0) {
+                this._onBell.fire();
+                return;
+            }
+        }
+        this._handleCompletionModel(model);
+    }
+    _handleCompletionModel(model) {
+        if (model.items.length === 0 || !this._terminal?.element) {
+            return;
+        }
+        if (model.items.length === 1) {
+            this.acceptSelectedSuggestion({
+                item: model.items[0],
+                model: model
+            });
+            return;
+        }
+        const suggestWidget = this._ensureSuggestWidget(this._terminal);
+        this._additionalInput = undefined;
+        const dimensions = {
+            width: this._terminal._core._renderService.dimensions.device.cell.width,
+            height: this._terminal._core._renderService.dimensions.device.cell.height,
+        };
+        if (!dimensions.width || !dimensions.height) {
+            return;
+        }
+        const xtermBox = this._terminal.element.getBoundingClientRect();
+        const panelElement = dom.findParentWithClass(this._container, 'panel').offsetParent;
+        const panelBox = panelElement.getBoundingClientRect();
+        suggestWidget.showSuggestions(model, 0, false, false, {
+            left: (xtermBox.left - panelBox.left) + this._terminal.buffer.active.cursorX * dimensions.width,
+            top: (xtermBox.top - panelBox.top) + this._terminal.buffer.active.cursorY * dimensions.height,
+            height: dimensions.height
+        });
+        if (this._inputQueue) {
+            const inputQueue = this._inputQueue;
+            this._inputQueue = undefined;
+            for (const data of inputQueue) {
+                this._handleTerminalInput(data);
+            }
+        }
+    }
+    _ensureSuggestWidget(terminal) {
+        this._terminalSuggestWidgetVisibleContextKey.set(true);
+        if (!this._suggestWidget) {
+            this._suggestWidget = this._register(this._instantiationService.createInstance(SimpleSuggestWidget, dom.findParentWithClass(this._container, 'panel'), this._instantiationService.createInstance(PersistedWidgetSize), {}));
+            this._suggestWidget.list.style(getListStyles({
+                listInactiveFocusBackground: editorSuggestWidgetSelectedBackground,
+                listInactiveFocusOutline: activeContrastBorder
+            }));
+            this._suggestWidget.onDidSelect(async (e) => this.acceptSelectedSuggestion(e));
+            this._suggestWidget.onDidHide(() => this._terminalSuggestWidgetVisibleContextKey.set(false));
+            this._suggestWidget.onDidShow(() => this._terminalSuggestWidgetVisibleContextKey.set(true));
+        }
+        return this._suggestWidget;
+    }
+    selectPreviousSuggestion() {
+        this._suggestWidget?.selectPrevious();
+    }
+    selectPreviousPageSuggestion() {
+        this._suggestWidget?.selectPreviousPage();
+    }
+    selectNextSuggestion() {
+        this._suggestWidget?.selectNext();
+    }
+    selectNextPageSuggestion() {
+        this._suggestWidget?.selectNextPage();
+    }
+    acceptSelectedSuggestion(suggestion) {
+        if (!suggestion) {
+            suggestion = this._suggestWidget?.getFocusedItem();
+        }
+        if (suggestion && this._leadingLineContent) {
+            this._suggestWidget?.hide();
+            this._onAcceptedCompletion.fire([
+                '\x1b[D'.repeat(Math.max(suggestion.model.replacementLength - this._cursorIndexStart + this._cursorIndexDelta, 0)),
+                '\x1b[3~'.repeat(this._additionalInput?.length ?? 0),
+                '\x7F'.repeat(suggestion.model.replacementLength),
+                suggestion.item.completion.label,
+            ].join(''));
+            this._enableWidget = false;
+            timeout(100).then(e => this._enableWidget = true);
+        }
+    }
+    hideSuggestWidget() {
+        this._suggestWidget?.hide();
+    }
+    handleNonXtermData(data) {
+        this._handleTerminalInput(data);
+    }
+    _handleTerminalInput(data) {
+        if (!this._terminal || !this._enableWidget || !this._terminalSuggestWidgetVisibleContextKey.get()) {
+            if (data === '-') {
+                this._inputQueue = [];
+            }
+            else {
+                this._inputQueue?.push(data);
+            }
+            return;
+        }
+        let handled = false;
+        if (data === '\x7f') {
+            if (this._additionalInput && this._additionalInput.length > 0 && this._cursorIndexDelta > 0) {
+                handled = true;
+                this._additionalInput = this._additionalInput.substring(0, this._cursorIndexDelta-- - 1) + this._additionalInput.substring(this._cursorIndexDelta);
+            }
+        }
+        if (data === '\x1b[3~') {
+            if (this._additionalInput && this._additionalInput.length > 0 && this._cursorIndexDelta < this._additionalInput.length - 1) {
+                handled = true;
+                this._additionalInput = this._additionalInput.substring(0, this._cursorIndexDelta) + this._additionalInput.substring(this._cursorIndexDelta + 1);
+            }
+        }
+        if (data === '\x1b[D') {
+            if (this._cursorIndexDelta > 0) {
+                handled = true;
+                this._cursorIndexDelta--;
+            }
+        }
+        if (data === '\x1b[C') {
+            handled = true;
+            this._cursorIndexDelta += 1;
+        }
+        if (data.match(/^[a-z0-9]$/i)) {
+            handled = true;
+            if (this._additionalInput === undefined) {
+                this._additionalInput = '';
+            }
+            this._additionalInput += data;
+            this._cursorIndexDelta++;
+        }
+        if (handled) {
+            if (this._terminalSuggestWidgetVisibleContextKey.get()) {
+                this._suggestWidget?.setLineContext(( new LineContext(
+                    this._leadingLineContent + (this._additionalInput ?? ''),
+                    this._additionalInput?.length ?? 0
+                )));
+            }
+            if (this._suggestWidget._completionModel?.items.length === 0) {
+                this._additionalInput = undefined;
+                this.hideSuggestWidget();
+                return;
+            }
+            const dimensions = {
+                width: this._terminal._core._renderService.dimensions.device.cell.width,
+                height: this._terminal._core._renderService.dimensions.device.cell.height,
+            };
+            if (!dimensions.width || !dimensions.height) {
+                return;
+            }
+            const xtermBox = this._terminal.element.getBoundingClientRect();
+            const panelElement = dom.findParentWithClass(this._container, 'panel').offsetParent;
+            const panelBox = panelElement.getBoundingClientRect();
+            this._suggestWidget?.showSuggestions(this._suggestWidget._completionModel, 0, false, false, {
+                left: (xtermBox.left - panelBox.left) + this._terminal.buffer.active.cursorX * dimensions.width,
+                top: (xtermBox.top - panelBox.top) + this._terminal.buffer.active.cursorY * dimensions.height,
+                height: dimensions.height
+            });
+        }
+        else {
+            this._additionalInput = undefined;
+            this.hideSuggestWidget();
+        }
+    }
+};
+SuggestAddon = ( __decorate([
+    ( __param(1, IInstantiationService))
+], SuggestAddon));
+let PersistedWidgetSize = class PersistedWidgetSize {
+    constructor(_storageService) {
+        this._storageService = _storageService;
+        this._key = "terminal.integrated.suggestSize" ;
+    }
+    restore() {
+        const raw = this._storageService.get(this._key, 0 ) ?? '';
+        try {
+            const obj = JSON.parse(raw);
+            if (dom.Dimension.is(obj)) {
+                return dom.Dimension.lift(obj);
+            }
+        }
+        catch {
+        }
+        return undefined;
+    }
+    store(size) {
+        this._storageService.store(this._key, JSON.stringify(size), 0 , 1 );
+    }
+    reset() {
+        this._storageService.remove(this._key, 0 );
+    }
+};
+PersistedWidgetSize = ( __decorate([
+    ( __param(0, IStorageService))
+], PersistedWidgetSize));
+export { SuggestAddon };