@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminalStatusList.js

@@ -0,0 +1,108 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.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 Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { listWarningForeground, listErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { spinningLoading } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+let TerminalStatusList = class TerminalStatusList extends Disposable {
+    get onDidAddStatus() { return this._onDidAddStatus.event; }
+    get onDidRemoveStatus() { return this._onDidRemoveStatus.event; }
+    get onDidChangePrimaryStatus() { return this._onDidChangePrimaryStatus.event; }
+    constructor(_configurationService) {
+        super();
+        this._configurationService = _configurationService;
+        this._statuses = ( new Map());
+        this._statusTimeouts = ( new Map());
+        this._onDidAddStatus = this._register(( new Emitter()));
+        this._onDidRemoveStatus = this._register(( new Emitter()));
+        this._onDidChangePrimaryStatus = this._register(( new Emitter()));
+    }
+    get primary() {
+        let result;
+        for (const s of ( this._statuses.values())) {
+            if (!result || s.severity >= result.severity) {
+                result = s;
+            }
+        }
+        return result;
+    }
+    get statuses() { return Array.from(( this._statuses.values())); }
+    add(status, duration) {
+        status = this._applyAnimationSetting(status);
+        const outTimeout = this._statusTimeouts.get(status.id);
+        if (outTimeout) {
+            window.clearTimeout(outTimeout);
+            this._statusTimeouts.delete(status.id);
+        }
+        if (duration && duration > 0) {
+            const timeout = window.setTimeout(() => this.remove(status), duration);
+            this._statusTimeouts.set(status.id, timeout);
+        }
+        const existingStatus = this._statuses.get(status.id);
+        if (existingStatus && existingStatus !== status) {
+            this._onDidRemoveStatus.fire(existingStatus);
+            this._statuses.delete(existingStatus.id);
+        }
+        if (!( this._statuses.has(status.id))) {
+            const oldPrimary = this.primary;
+            this._statuses.set(status.id, status);
+            this._onDidAddStatus.fire(status);
+            const newPrimary = this.primary;
+            if (oldPrimary !== newPrimary) {
+                this._onDidChangePrimaryStatus.fire(newPrimary);
+            }
+        }
+    }
+    remove(statusOrId) {
+        const status = typeof statusOrId === 'string' ? this._statuses.get(statusOrId) : statusOrId;
+        if (status && this._statuses.get(status.id)) {
+            const wasPrimary = this.primary?.id === status.id;
+            this._statuses.delete(status.id);
+            this._onDidRemoveStatus.fire(status);
+            if (wasPrimary) {
+                this._onDidChangePrimaryStatus.fire(this.primary);
+            }
+        }
+    }
+    toggle(status, value) {
+        if (value) {
+            this.add(status);
+        }
+        else {
+            this.remove(status);
+        }
+    }
+    _applyAnimationSetting(status) {
+        if (!status.icon || ThemeIcon.getModifier(status.icon) !== 'spin' || this._configurationService.getValue("terminal.integrated.tabs.enableAnimation" )) {
+            return status;
+        }
+        let icon;
+        if (status.icon.id === spinningLoading.id) {
+            icon = Codicon.play;
+        }
+        else {
+            icon = ThemeIcon.modify(status.icon, undefined);
+        }
+        return {
+            ...status,
+            icon
+        };
+    }
+};
+TerminalStatusList = ( __decorate([
+    ( __param(0, IConfigurationService))
+], TerminalStatusList));
+function getColorForSeverity(severity) {
+    switch (severity) {
+        case Severity.Error:
+            return listErrorForeground;
+        case Severity.Warning:
+            return listWarningForeground;
+        default:
+            return '';
+    }
+}
+export { TerminalStatusList, getColorForSeverity };

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminalTabbedView.js

@@ -0,0 +1,417 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITerminalService, ITerminalGroupService } from './terminal.js';
+import { TerminalTabList } from './terminalTabsList.js';
+import { isLinux, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Separator, Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { openContextMenu } from './terminalContextMenu.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { getInstanceHoverInfo } from './terminalTooltip.js';
+import { IHoverService } from '../../../services/hover/browser/hover.js';
+const $ = dom.$;
+let TerminalTabbedView = class TerminalTabbedView extends Disposable {
+    constructor(parentElement, _terminalService, _terminalGroupService, _instantiationService, _notificationService, _contextMenuService, _configurationService, menuService, _storageService, contextKeyService, _hoverService) {
+        super();
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._instantiationService = _instantiationService;
+        this._notificationService = _notificationService;
+        this._contextMenuService = _contextMenuService;
+        this._configurationService = _configurationService;
+        this._storageService = _storageService;
+        this._hoverService = _hoverService;
+        this._cancelContextMenu = false;
+        this._parentElement = parentElement;
+        this._tabContainer = $('.tabs-container');
+        const tabListContainer = $('.tabs-list-container');
+        this._tabListElement = $('.tabs-list');
+        tabListContainer.appendChild(this._tabListElement);
+        this._tabContainer.appendChild(tabListContainer);
+        this._instanceMenu = this._register(menuService.createMenu(MenuId.TerminalInstanceContext, contextKeyService));
+        this._tabsListMenu = this._register(menuService.createMenu(MenuId.TerminalTabContext, contextKeyService));
+        this._tabsListEmptyMenu = this._register(menuService.createMenu(MenuId.TerminalTabEmptyAreaContext, contextKeyService));
+        this._tabList = this._register(this._instantiationService.createInstance(TerminalTabList, this._tabListElement));
+        const terminalOuterContainer = $('.terminal-outer-container');
+        this._terminalContainer = $('.terminal-groups-container');
+        terminalOuterContainer.appendChild(this._terminalContainer);
+        this._terminalService.setContainers(parentElement, this._terminalContainer);
+        this._terminalIsTabsNarrowContextKey = TerminalContextKeys.tabsNarrow.bindTo(contextKeyService);
+        this._terminalTabsFocusContextKey = TerminalContextKeys.tabsFocus.bindTo(contextKeyService);
+        this._terminalTabsMouseContextKey = TerminalContextKeys.tabsMouse.bindTo(contextKeyService);
+        this._tabTreeIndex = this._terminalService.configHelper.config.tabs.location === 'left' ? 0 : 1;
+        this._terminalContainerIndex = this._terminalService.configHelper.config.tabs.location === 'left' ? 1 : 0;
+        _configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("terminal.integrated.tabs.enabled" ) ||
+                e.affectsConfiguration("terminal.integrated.tabs.hideCondition" )) {
+                this._refreshShowTabs();
+            }
+            else if (e.affectsConfiguration("terminal.integrated.tabs.location" )) {
+                this._tabTreeIndex = this._terminalService.configHelper.config.tabs.location === 'left' ? 0 : 1;
+                this._terminalContainerIndex = this._terminalService.configHelper.config.tabs.location === 'left' ? 1 : 0;
+                if (this._shouldShowTabs()) {
+                    this._splitView.swapViews(0, 1);
+                    this._removeSashListener();
+                    this._addSashListener();
+                    this._splitView.resizeView(this._tabTreeIndex, this._getLastListWidth());
+                }
+            }
+        });
+        this._register(this._terminalGroupService.onDidChangeInstances(() => this._refreshShowTabs()));
+        this._register(this._terminalGroupService.onDidChangeGroups(() => this._refreshShowTabs()));
+        this._attachEventListeners(parentElement, this._terminalContainer);
+        this._terminalGroupService.onDidChangePanelOrientation((orientation) => {
+            this._panelOrientation = orientation;
+            if (this._panelOrientation === 0 ) {
+                this._terminalContainer.classList.add("terminal-side-view" );
+            }
+            else {
+                this._terminalContainer.classList.remove("terminal-side-view" );
+            }
+        });
+        this._splitView = ( new SplitView(
+            parentElement,
+            { orientation: 1 , proportionalLayout: false }
+        ));
+        this._setupSplitView(terminalOuterContainer);
+    }
+    _shouldShowTabs() {
+        const enabled = this._terminalService.configHelper.config.tabs.enabled;
+        const hide = this._terminalService.configHelper.config.tabs.hideCondition;
+        if (!enabled) {
+            return false;
+        }
+        if (hide === 'never') {
+            return true;
+        }
+        if (hide === 'singleTerminal' && this._terminalGroupService.instances.length > 1) {
+            return true;
+        }
+        if (hide === 'singleGroup' && this._terminalGroupService.groups.length > 1) {
+            return true;
+        }
+        return false;
+    }
+    _refreshShowTabs() {
+        if (this._shouldShowTabs()) {
+            if (this._splitView.length === 1) {
+                this._addTabTree();
+                this._addSashListener();
+                this._splitView.resizeView(this._tabTreeIndex, this._getLastListWidth());
+                this.rerenderTabs();
+            }
+        }
+        else {
+            if (this._splitView.length === 2 && !this._terminalTabsMouseContextKey.get()) {
+                this._splitView.removeView(this._tabTreeIndex);
+                if (this._plusButton) {
+                    this._tabContainer.removeChild(this._plusButton);
+                }
+                this._removeSashListener();
+            }
+        }
+    }
+    _getLastListWidth() {
+        const widthKey = this._panelOrientation === 0  ? "tabs-list-width-vertical"  : "tabs-list-width-horizontal" ;
+        const storedValue = this._storageService.get(widthKey, 0 );
+        if (!storedValue || !parseInt(storedValue)) {
+            return this._panelOrientation === 0  ? 46  : 120 ;
+        }
+        return parseInt(storedValue);
+    }
+    _handleOnDidSashReset() {
+        let idealWidth = 80 ;
+        const offscreenCanvas = document.createElement('canvas');
+        offscreenCanvas.width = 1;
+        offscreenCanvas.height = 1;
+        const ctx = offscreenCanvas.getContext('2d');
+        if (ctx) {
+            const style = window.getComputedStyle(this._tabListElement);
+            ctx.font = `${style.fontStyle} ${style.fontSize} ${style.fontFamily}`;
+            const maxInstanceWidth = this._terminalGroupService.instances.reduce((p, c) => {
+                return Math.max(p, ctx.measureText(c.title + (c.description || '')).width + this._getAdditionalWidth(c));
+            }, 0);
+            idealWidth = Math.ceil(Math.max(maxInstanceWidth, 80 ));
+        }
+        const currentWidth = Math.ceil(this._splitView.getViewSize(this._tabTreeIndex));
+        if (currentWidth === idealWidth) {
+            idealWidth = 46 ;
+        }
+        this._splitView.resizeView(this._tabTreeIndex, idealWidth);
+        this._updateListWidth(idealWidth);
+    }
+    _getAdditionalWidth(instance) {
+        const additionalWidth = 40;
+        const statusIconWidth = instance.statusList.statuses.length > 0 ? 30  : 0;
+        const splitAnnotationWidth = (this._terminalGroupService.getGroupForInstance(instance)?.terminalInstances.length || 0) > 1 ? 30  : 0;
+        return additionalWidth + splitAnnotationWidth + statusIconWidth;
+    }
+    _handleOnDidSashChange() {
+        const listWidth = this._splitView.getViewSize(this._tabTreeIndex);
+        if (!this._width || listWidth <= 0) {
+            return;
+        }
+        this._updateListWidth(listWidth);
+    }
+    _updateListWidth(width) {
+        if (width < 63  && width >= 46 ) {
+            width = 46 ;
+            this._splitView.resizeView(this._tabTreeIndex, width);
+        }
+        else if (width >= 63  && width < 80 ) {
+            width = 80 ;
+            this._splitView.resizeView(this._tabTreeIndex, width);
+        }
+        this.rerenderTabs();
+        const widthKey = this._panelOrientation === 0  ? "tabs-list-width-vertical"  : "tabs-list-width-horizontal" ;
+        this._storageService.store(widthKey, width, 0 , 0 );
+    }
+    _setupSplitView(terminalOuterContainer) {
+        this._register(this._splitView.onDidSashReset(() => this._handleOnDidSashReset()));
+        this._register(this._splitView.onDidSashChange(() => this._handleOnDidSashChange()));
+        if (this._shouldShowTabs()) {
+            this._addTabTree();
+        }
+        this._splitView.addView({
+            element: terminalOuterContainer,
+            layout: width => this._terminalGroupService.groups.forEach(tab => tab.layout(width, this._height || 0)),
+            minimumSize: 120,
+            maximumSize: Number.POSITIVE_INFINITY,
+            onDidChange: () => Disposable.None,
+            priority: 2
+        }, Sizing.Distribute, this._terminalContainerIndex);
+        if (this._shouldShowTabs()) {
+            this._addSashListener();
+        }
+    }
+    _addTabTree() {
+        this._splitView.addView({
+            element: this._tabContainer,
+            layout: width => this._tabList.layout(this._height || 0, width),
+            minimumSize: 46 ,
+            maximumSize: 500 ,
+            onDidChange: () => Disposable.None,
+            priority: 1
+        }, Sizing.Distribute, this._tabTreeIndex);
+        this.rerenderTabs();
+    }
+    rerenderTabs() {
+        this._updateHasText();
+        this._tabList.refresh();
+    }
+    _addSashListener() {
+        let interval;
+        this._sashDisposables = [
+            this._splitView.sashes[0].onDidStart(e => {
+                interval = window.setInterval(() => {
+                    this.rerenderTabs();
+                }, 100);
+            }),
+            this._splitView.sashes[0].onDidEnd(e => {
+                window.clearInterval(interval);
+                interval = 0;
+            })
+        ];
+    }
+    _removeSashListener() {
+        if (this._sashDisposables) {
+            dispose(this._sashDisposables);
+            this._sashDisposables = undefined;
+        }
+    }
+    _updateHasText() {
+        const hasText = this._tabListElement.clientWidth > 63 ;
+        this._tabContainer.classList.toggle('has-text', hasText);
+        this._terminalIsTabsNarrowContextKey.set(!hasText);
+    }
+    layout(width, height) {
+        this._height = height;
+        this._width = width;
+        this._splitView.layout(width);
+        if (this._shouldShowTabs()) {
+            this._splitView.resizeView(this._tabTreeIndex, this._getLastListWidth());
+        }
+        this._updateHasText();
+    }
+    _attachEventListeners(parentDomElement, terminalContainer) {
+        this._register(dom.addDisposableListener(this._tabContainer, 'mouseleave', async (event) => {
+            this._terminalTabsMouseContextKey.set(false);
+            this._refreshShowTabs();
+            event.stopPropagation();
+        }));
+        this._register(dom.addDisposableListener(this._tabContainer, 'mouseenter', async (event) => {
+            this._terminalTabsMouseContextKey.set(true);
+            event.stopPropagation();
+        }));
+        this._register(dom.addDisposableListener(terminalContainer, 'mousedown', async (event) => {
+            const terminal = this._terminalGroupService.activeInstance;
+            if (this._terminalGroupService.instances.length === 0 || !terminal) {
+                this._cancelContextMenu = true;
+                return;
+            }
+            if (event.which === 2 && isLinux) {
+                terminal.focus();
+            }
+            else if (event.which === 3) {
+                const rightClickBehavior = this._terminalService.configHelper.config.rightClickBehavior;
+                if (rightClickBehavior === 'nothing') {
+                    if (!event.shiftKey) {
+                        this._cancelContextMenu = true;
+                    }
+                    return;
+                }
+                else if (rightClickBehavior === 'copyPaste' || rightClickBehavior === 'paste') {
+                    if (rightClickBehavior === 'copyPaste' && event.shiftKey) {
+                        openContextMenu(event, this._parentElement, this._instanceMenu, this._contextMenuService);
+                        return;
+                    }
+                    if (rightClickBehavior === 'copyPaste' && terminal.hasSelection()) {
+                        await terminal.copySelection();
+                        terminal.clearSelection();
+                    }
+                    else {
+                        if (BrowserFeatures.clipboard.readText) {
+                            terminal.paste();
+                        }
+                        else {
+                            this._notificationService.info(`This browser doesn't support the clipboard.readText API needed to trigger a paste, try ${isMacintosh ? '⌘' : 'Ctrl'}+V instead.`);
+                        }
+                    }
+                    if (isMacintosh) {
+                        setTimeout(() => {
+                            terminal.clearSelection();
+                        }, 0);
+                    }
+                    this._cancelContextMenu = true;
+                }
+            }
+        }));
+        this._register(dom.addDisposableListener(terminalContainer, 'contextmenu', (event) => {
+            const rightClickBehavior = this._terminalService.configHelper.config.rightClickBehavior;
+            if (rightClickBehavior === 'nothing' && !event.shiftKey) {
+                this._cancelContextMenu = true;
+            }
+            if (!this._cancelContextMenu) {
+                openContextMenu(event, this._parentElement, this._instanceMenu, this._contextMenuService);
+            }
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            this._cancelContextMenu = false;
+        }));
+        this._register(dom.addDisposableListener(this._tabContainer, 'contextmenu', (event) => {
+            const rightClickBehavior = this._terminalService.configHelper.config.rightClickBehavior;
+            if (rightClickBehavior === 'nothing' && !event.shiftKey) {
+                this._cancelContextMenu = true;
+            }
+            if (!this._cancelContextMenu) {
+                const emptyList = this._tabList.getFocus().length === 0;
+                openContextMenu(event, this._parentElement, emptyList ? this._tabsListEmptyMenu : this._tabsListMenu, this._contextMenuService, emptyList ? this._getTabActions() : undefined);
+            }
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            this._cancelContextMenu = false;
+        }));
+        this._register(dom.addDisposableListener(document, 'keydown', (event) => {
+            terminalContainer.classList.toggle('alt-active', !!event.altKey);
+        }));
+        this._register(dom.addDisposableListener(document, 'keyup', (event) => {
+            terminalContainer.classList.toggle('alt-active', !!event.altKey);
+        }));
+        this._register(dom.addDisposableListener(parentDomElement, 'keyup', (event) => {
+            if (event.keyCode === 27) {
+                event.stopPropagation();
+            }
+        }));
+        this._register(dom.addDisposableListener(this._tabContainer, dom.EventType.FOCUS_IN, () => {
+            this._terminalTabsFocusContextKey.set(true);
+        }));
+        this._register(dom.addDisposableListener(this._tabContainer, dom.EventType.FOCUS_OUT, () => {
+            this._terminalTabsFocusContextKey.set(false);
+        }));
+    }
+    _getTabActions() {
+        return [
+            ( new Separator()),
+            this._configurationService.inspect("terminal.integrated.tabs.location" ).userValue === 'left' ?
+                ( new Action('moveRight', ( localize('moveTabsRight', "Move Tabs Right")), undefined, undefined, async () => {
+                    this._configurationService.updateValue("terminal.integrated.tabs.location" , 'right');
+                })) :
+                ( new Action('moveLeft', ( localize('moveTabsLeft', "Move Tabs Left")), undefined, undefined, async () => {
+                    this._configurationService.updateValue("terminal.integrated.tabs.location" , 'left');
+                })),
+            ( new Action('hideTabs', ( localize('hideTabs', "Hide Tabs")), undefined, undefined, async () => {
+                this._configurationService.updateValue("terminal.integrated.tabs.enabled" , false);
+            }))
+        ];
+    }
+    setEditable(isEditing) {
+        if (!isEditing) {
+            this._tabList.domFocus();
+        }
+        this._tabList.refresh(false);
+    }
+    focusTabs() {
+        if (!this._shouldShowTabs()) {
+            return;
+        }
+        this._terminalTabsFocusContextKey.set(true);
+        const selected = this._tabList.getSelection();
+        this._tabList.domFocus();
+        if (selected) {
+            this._tabList.setFocus(selected);
+        }
+    }
+    focus() {
+        if (this._terminalService.connectionState === 0 ) {
+            const activeElement = document.activeElement;
+            this._register(this._terminalService.onDidChangeConnectionState(() => {
+                if (document.activeElement === activeElement) {
+                    this._focus();
+                }
+            }));
+            return;
+        }
+        this._focus();
+    }
+    focusHover() {
+        if (this._shouldShowTabs()) {
+            this._tabList.focusHover();
+            return;
+        }
+        const instance = this._terminalGroupService.activeInstance;
+        if (!instance) {
+            return;
+        }
+        this._hoverService.showHover({
+            ...getInstanceHoverInfo(instance),
+            target: this._terminalContainer,
+            trapFocus: true
+        }, true);
+    }
+    _focus() {
+        this._terminalGroupService.activeInstance?.focusWhenReady();
+    }
+};
+TerminalTabbedView = ( __decorate([
+    ( __param(1, ITerminalService)),
+    ( __param(2, ITerminalGroupService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IMenuService)),
+    ( __param(8, IStorageService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IHoverService))
+], TerminalTabbedView));
+export { TerminalTabbedView };