@codingame/monaco-vscode-xterm-common 24.1.0

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalTabsList.js

@@ -0,0 +1,754 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { IListService } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { TerminalDataTransfers } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal';
+import { ITerminalService, ITerminalGroupService, ITerminalEditingService, ITerminalConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { $ as $$1, append, addDisposableListener, EventType, addStandardDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { MenuEntryActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { TerminalCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal';
+import { TerminalLocation, TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { ResourceLabels, DEFAULT_LABELS_CONTAINER } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { IDecorationsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/decorations/common/decorations.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { dispose, toDisposable, DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ListDragOverEffectPosition, ListDragOverEffectType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list';
+import { DataTransfers } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dnd';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { NativeDragAndDropData, ElementsDragAndDropData } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/listView';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { getIconId, getColorClass, getUriClasses } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminalIcon';
+import { IContextViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { InputBox, MessageType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { createSingleCallFunction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/functional';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { containsDragType, CodeDataTransfers, getPathForFile } from '@codingame/monaco-vscode-api/vscode/vs/platform/dnd/browser/dnd';
+import { terminalStrings } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalStrings';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { TerminalContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
+import { getTerminalResourcesFromDragEvent, parseTerminalUri } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/terminal/browser/terminalUri';
+import { getInstanceHoverInfo } from './terminalTooltip.js';
+import { defaultInputBoxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { getColorForSeverity } from './terminalStatusList.js';
+import { TerminalContextActionRunner } from './terminalContextMenu.js';
+import { HoverPosition } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { TerminalStorageKeys } from '../common/terminalStorageKeys.js';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+const $ = $$1;
+var TerminalTabsListSizes;
+(function (TerminalTabsListSizes) {
+    TerminalTabsListSizes[TerminalTabsListSizes["TabHeight"] = 22] = "TabHeight";
+    TerminalTabsListSizes[TerminalTabsListSizes["NarrowViewWidth"] = 46] = "NarrowViewWidth";
+    TerminalTabsListSizes[TerminalTabsListSizes["WideViewMinimumWidth"] = 80] = "WideViewMinimumWidth";
+    TerminalTabsListSizes[TerminalTabsListSizes["DefaultWidth"] = 120] = "DefaultWidth";
+    TerminalTabsListSizes[TerminalTabsListSizes["MidpointViewWidth"] = 63] = "MidpointViewWidth";
+    TerminalTabsListSizes[TerminalTabsListSizes["ActionbarMinimumWidth"] = 105] = "ActionbarMinimumWidth";
+    TerminalTabsListSizes[TerminalTabsListSizes["MaximumWidth"] = 500] = "MaximumWidth";
+})(TerminalTabsListSizes || (TerminalTabsListSizes = {}));
+let TerminalTabList = class TerminalTabList extends WorkbenchList {
+    constructor(container, contextKeyService, listService, _configurationService, _terminalService, _terminalGroupService, _terminalEditingService, instantiationService, decorationsService, _themeService, _storageService, lifecycleService, _hoverService) {
+        super('TerminalTabsList', container, {
+            getHeight: () => TerminalTabsListSizes.TabHeight,
+            getTemplateId: () => 'terminal.tabs'
+        }, [instantiationService.createInstance(TerminalTabsRenderer, container, instantiationService.createInstance(ResourceLabels, DEFAULT_LABELS_CONTAINER), () => this.getSelectedElements())], {
+            horizontalScrolling: false,
+            supportDynamicHeights: false,
+            selectionNavigation: true,
+            identityProvider: {
+                getId: e => e?.instanceId
+            },
+            accessibilityProvider: instantiationService.createInstance(TerminalTabsAccessibilityProvider),
+            smoothScrolling: _configurationService.getValue('workbench.list.smoothScrolling'),
+            multipleSelectionSupport: true,
+            paddingBottom: TerminalTabsListSizes.TabHeight,
+            dnd: instantiationService.createInstance(TerminalTabsDragAndDrop),
+            openOnSingleClick: true
+        }, contextKeyService, listService, _configurationService, instantiationService);
+        this._configurationService = _configurationService;
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._terminalEditingService = _terminalEditingService;
+        this._themeService = _themeService;
+        this._storageService = _storageService;
+        this._hoverService = _hoverService;
+        const instanceDisposables = [
+            this._terminalGroupService.onDidChangeInstances(() => this.refresh()),
+            this._terminalGroupService.onDidChangeGroups(() => this.refresh()),
+            this._terminalGroupService.onDidShow(() => this.refresh()),
+            this._terminalGroupService.onDidChangeInstanceCapability(() => this.refresh()),
+            this._terminalService.onAnyInstanceTitleChange(() => this.refresh()),
+            this._terminalService.onAnyInstanceIconChange(() => this.refresh()),
+            this._terminalService.onAnyInstancePrimaryStatusChange(() => this.refresh()),
+            this._terminalService.onDidChangeConnectionState(() => this.refresh()),
+            this._themeService.onDidColorThemeChange(() => this.refresh()),
+            this._terminalGroupService.onDidChangeActiveInstance(e => {
+                if (e) {
+                    const i = this._terminalGroupService.instances.indexOf(e);
+                    this.setSelection([i]);
+                    this.reveal(i);
+                }
+                this.refresh();
+            }),
+            this._storageService.onDidChangeValue(StorageScope.APPLICATION, TerminalStorageKeys.TabsShowDetailed, this.disposables)(() => this.refresh()),
+        ];
+        this.disposables.add(lifecycleService.onWillShutdown(e => {
+            dispose(instanceDisposables);
+            instanceDisposables.length = 0;
+        }));
+        this.disposables.add(toDisposable(() => {
+            dispose(instanceDisposables);
+            instanceDisposables.length = 0;
+        }));
+        this.disposables.add(this.onMouseDblClick(async (e) => {
+            if (!e.element) {
+                e.browserEvent.preventDefault();
+                e.browserEvent.stopPropagation();
+                const instance = await this._terminalService.createTerminal({ location: TerminalLocation.Panel });
+                this._terminalGroupService.setActiveInstance(instance);
+                await instance.focusWhenReady();
+                return;
+            }
+            if (this._terminalEditingService.getEditingTerminal()?.instanceId === e.element.instanceId) {
+                return;
+            }
+            if (this._getFocusMode() === 'doubleClick' && this.getFocus().length === 1) {
+                e.element.focus(true);
+            }
+        }));
+        this.disposables.add(this.onMouseClick(async (e) => {
+            if (this._terminalEditingService.getEditingTerminal()?.instanceId === e.element?.instanceId) {
+                return;
+            }
+            if (e.browserEvent.altKey && e.element) {
+                await this._terminalService.createTerminal({ location: { parentTerminal: e.element } });
+            }
+            else if (this._getFocusMode() === 'singleClick') {
+                if (this.getSelection().length <= 1) {
+                    e.element?.focus(true);
+                }
+            }
+        }));
+        this.disposables.add(this.onContextMenu(e => {
+            if (!e.element) {
+                this.setSelection([]);
+                return;
+            }
+            const selection = this.getSelectedElements();
+            if (!selection || !selection.find(s => e.element === s)) {
+                this.setFocus(e.index !== undefined ? [e.index] : []);
+            }
+        }));
+        this._terminalTabsSingleSelectedContextKey = TerminalContextKeys.tabsSingularSelection.bindTo(contextKeyService);
+        this._isSplitContextKey = TerminalContextKeys.splitTerminalTabFocused.bindTo(contextKeyService);
+        this.disposables.add(this.onDidChangeSelection(e => this._updateContextKey()));
+        this.disposables.add(this.onDidChangeFocus(() => this._updateContextKey()));
+        this.disposables.add(this.onDidOpen(async (e) => {
+            const instance = e.element;
+            if (!instance) {
+                return;
+            }
+            this._terminalGroupService.setActiveInstance(instance);
+            if (!e.editorOptions.preserveFocus) {
+                await instance.focusWhenReady();
+            }
+        }));
+        if (!this._decorationsProvider) {
+            this._decorationsProvider = this.disposables.add(instantiationService.createInstance(TabDecorationsProvider));
+            this.disposables.add(decorationsService.registerDecorationsProvider(this._decorationsProvider));
+        }
+        this.refresh();
+    }
+    _getFocusMode() {
+        return this._configurationService.getValue(TerminalSettingId.TabsFocusMode);
+    }
+    refresh(cancelEditing = true) {
+        if (cancelEditing && this._terminalEditingService.isEditable(undefined)) {
+            this.domFocus();
+        }
+        this.splice(0, this.length, this._terminalGroupService.instances.slice());
+    }
+    focusHover() {
+        const instance = this.getSelectedElements()[0];
+        if (!instance) {
+            return;
+        }
+        this._hoverService.showInstantHover({
+            ...getInstanceHoverInfo(instance, this._storageService),
+            target: this.getHTMLElement(),
+            trapFocus: true
+        }, true);
+    }
+    _updateContextKey() {
+        this._terminalTabsSingleSelectedContextKey.set(this.getSelectedElements().length === 1);
+        const instance = this.getFocusedElements();
+        this._isSplitContextKey.set(instance.length > 0 && this._terminalGroupService.instanceIsSplit(instance[0]));
+    }
+};
+TerminalTabList = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IListService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ITerminalService)),
+    ( __param(5, ITerminalGroupService)),
+    ( __param(6, ITerminalEditingService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IDecorationsService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, IStorageService)),
+    ( __param(11, ILifecycleService)),
+    ( __param(12, IHoverService))
+], TerminalTabList));
+let TerminalTabsRenderer = class TerminalTabsRenderer {
+    constructor(_container, _labels, _getSelection, _instantiationService, _terminalConfigurationService, _terminalService, _terminalGroupService, _terminalEditingService, _hoverService, _keybindingService, _listService, _storageService, _themeService, _contextViewService, _commandService) {
+        this._container = _container;
+        this._labels = _labels;
+        this._getSelection = _getSelection;
+        this._instantiationService = _instantiationService;
+        this._terminalConfigurationService = _terminalConfigurationService;
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._terminalEditingService = _terminalEditingService;
+        this._hoverService = _hoverService;
+        this._keybindingService = _keybindingService;
+        this._listService = _listService;
+        this._storageService = _storageService;
+        this._themeService = _themeService;
+        this._contextViewService = _contextViewService;
+        this._commandService = _commandService;
+        this.templateId = 'terminal.tabs';
+        this._cachedContainerWidth = -1;
+    }
+    renderTemplate(container) {
+        const element = append(container, $('.terminal-tabs-entry'));
+        const context = {};
+        const templateDisposables = ( new DisposableStore());
+        const label = templateDisposables.add(this._labels.create(element, {
+            supportHighlights: true,
+            supportDescriptionHighlights: true,
+            supportIcons: true,
+            hoverDelegate: {
+                delay: 0,
+                showHover: options => {
+                    return this._hoverService.showDelayedHover({
+                        ...options,
+                        actions: context.hoverActions,
+                        target: element,
+                        appearance: {
+                            showPointer: true
+                        },
+                        position: {
+                            hoverPosition: this._terminalConfigurationService.config.tabs.location === 'left' ? HoverPosition.RIGHT : HoverPosition.LEFT
+                        }
+                    }, { groupId: 'terminal-tabs-list' });
+                }
+            }
+        }));
+        const actionsContainer = append(label.element, $('.actions'));
+        const actionBar = templateDisposables.add(( new ActionBar(actionsContainer, {
+            actionRunner: templateDisposables.add(( new TerminalContextActionRunner())),
+            actionViewItemProvider: (action, options) => action instanceof MenuItemAction
+                ? templateDisposables.add(this._instantiationService.createInstance(MenuEntryActionViewItem, action, { hoverDelegate: options.hoverDelegate }))
+                : undefined
+        })));
+        return {
+            element,
+            label,
+            actionBar,
+            context,
+            elementDisposables: ( new DisposableStore()),
+            templateDisposables
+        };
+    }
+    shouldHideText() {
+        return this._container ? this.getContainerWidthCachedForTask() < TerminalTabsListSizes.MidpointViewWidth : false;
+    }
+    shouldHideActionBar() {
+        return this._container ? this.getContainerWidthCachedForTask() <= TerminalTabsListSizes.ActionbarMinimumWidth : false;
+    }
+    getContainerWidthCachedForTask() {
+        if (this._cachedContainerWidth === -1) {
+            this._cachedContainerWidth = this._container.clientWidth;
+            queueMicrotask(() => this._cachedContainerWidth = -1);
+        }
+        return this._cachedContainerWidth;
+    }
+    renderElement(instance, index, template) {
+        const hasText = !this.shouldHideText();
+        const group = this._terminalGroupService.getGroupForInstance(instance);
+        if (!group) {
+            throw ( new Error(`Could not find group for instance "${instance.instanceId}"`));
+        }
+        template.element.classList.toggle('has-text', hasText);
+        template.element.classList.toggle('is-active', this._terminalGroupService.activeInstance === instance);
+        let prefix = '';
+        if (group.terminalInstances.length > 1) {
+            const terminalIndex = group.terminalInstances.indexOf(instance);
+            if (terminalIndex === 0) {
+                prefix = `┌ `;
+            }
+            else if (terminalIndex === group.terminalInstances.length - 1) {
+                prefix = `└ `;
+            }
+            else {
+                prefix = `├ `;
+            }
+        }
+        const hoverInfo = getInstanceHoverInfo(instance, this._storageService);
+        template.context.hoverActions = hoverInfo.actions;
+        const iconId = this._instantiationService.invokeFunction(getIconId, instance);
+        const hasActionbar = !this.shouldHideActionBar();
+        let label = '';
+        if (!hasText) {
+            const primaryStatus = instance.statusList.primary;
+            if (primaryStatus && primaryStatus.severity > Severity.Ignore) {
+                label = `${prefix}$(${primaryStatus.icon?.id || iconId})`;
+            }
+            else {
+                label = `${prefix}$(${iconId})`;
+            }
+        }
+        else {
+            this.fillActionBar(instance, template);
+            label = prefix;
+            if (instance.icon) {
+                label += `$(${iconId}) ${instance.title}`;
+            }
+        }
+        if (!hasActionbar) {
+            template.actionBar.clear();
+        }
+        template.elementDisposables.add(addDisposableListener(template.element, EventType.AUXCLICK, e => {
+            e.stopImmediatePropagation();
+            if (e.button === 1 ) {
+                this._terminalService.safeDisposeTerminal(instance);
+            }
+        }));
+        const extraClasses = [];
+        const colorClass = getColorClass(instance);
+        if (colorClass) {
+            extraClasses.push(colorClass);
+        }
+        const uriClasses = getUriClasses(instance, this._themeService.getColorTheme().type);
+        if (uriClasses) {
+            extraClasses.push(...uriClasses);
+        }
+        template.label.setResource({
+            resource: instance.resource,
+            name: label,
+            description: hasText ? instance.description : undefined
+        }, {
+            fileDecorations: {
+                colors: true,
+                badges: hasText
+            },
+            title: {
+                markdown: hoverInfo.content,
+                markdownNotSupportedFallback: undefined
+            },
+            extraClasses
+        });
+        const editableData = this._terminalEditingService.getEditableData(instance);
+        template.label.element.classList.toggle('editable-tab', !!editableData);
+        if (editableData) {
+            template.elementDisposables.add(this._renderInputBox(template.label.element.querySelector('.monaco-icon-label-container'), instance, editableData));
+            template.actionBar.clear();
+        }
+    }
+    _renderInputBox(container, instance, editableData) {
+        const value = instance.title || '';
+        const inputBox = ( new InputBox(container, this._contextViewService, {
+            validationOptions: {
+                validation: (value) => {
+                    const message = editableData.validationMessage(value);
+                    if (!message || message.severity !== Severity.Error) {
+                        return null;
+                    }
+                    return {
+                        content: message.content,
+                        formatContent: true,
+                        type: MessageType.ERROR
+                    };
+                }
+            },
+            ariaLabel: ( localize(11629, "Type terminal name. Press Enter to confirm or Escape to cancel.")),
+            inputBoxStyles: defaultInputBoxStyles
+        }));
+        inputBox.element.style.height = '22px';
+        inputBox.value = value;
+        inputBox.focus();
+        inputBox.select({ start: 0, end: value.length });
+        const done = createSingleCallFunction((success, finishEditing) => {
+            inputBox.element.style.display = 'none';
+            const value = inputBox.value;
+            dispose(toDispose);
+            inputBox.element.remove();
+            if (finishEditing) {
+                editableData.onFinish(value, success);
+            }
+        });
+        const showInputBoxNotification = () => {
+            if (inputBox.isInputValid()) {
+                const message = editableData.validationMessage(inputBox.value);
+                if (message) {
+                    inputBox.showMessage({
+                        content: message.content,
+                        formatContent: true,
+                        type: message.severity === Severity.Info ? MessageType.INFO : message.severity === Severity.Warning ? MessageType.WARNING : MessageType.ERROR
+                    });
+                }
+                else {
+                    inputBox.hideMessage();
+                }
+            }
+        };
+        showInputBoxNotification();
+        const toDispose = [
+            inputBox,
+            addStandardDisposableListener(inputBox.inputElement, EventType.KEY_DOWN, (e) => {
+                e.stopPropagation();
+                if (e.equals(KeyCode.Enter)) {
+                    done(inputBox.isInputValid(), true);
+                }
+                else if (e.equals(KeyCode.Escape)) {
+                    done(false, true);
+                }
+            }),
+            addStandardDisposableListener(inputBox.inputElement, EventType.KEY_UP, (e) => {
+                showInputBoxNotification();
+            }),
+            addDisposableListener(inputBox.inputElement, EventType.BLUR, () => {
+                done(inputBox.isInputValid(), true);
+            })
+        ];
+        return toDisposable(() => {
+            done(false, false);
+        });
+    }
+    disposeElement(instance, index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.actionBar.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposables.dispose();
+    }
+    fillActionBar(instance, template) {
+        const actions = [
+            template.elementDisposables.add(( new Action(
+                TerminalCommandId.SplitActiveTab,
+                terminalStrings.split.short,
+                ThemeIcon.asClassName(Codicon.splitHorizontal),
+                true,
+                async () => {
+                    this._runForSelectionOrInstance(instance, async (e) => {
+                        this._terminalService.createTerminal({ location: { parentTerminal: e } });
+                    });
+                }
+            ))),
+        ];
+        if (instance.shellLaunchConfig.tabActions) {
+            for (const action of instance.shellLaunchConfig.tabActions) {
+                actions.push(template.elementDisposables.add(( new Action(
+                    action.id,
+                    action.label,
+                    action.icon ? ThemeIcon.asClassName(action.icon) : undefined,
+                    true,
+                    async () => {
+                        this._runForSelectionOrInstance(instance, e => this._commandService.executeCommand(action.id, instance));
+                    }
+                ))));
+            }
+        }
+        actions.push(template.elementDisposables.add(( new Action(
+            TerminalCommandId.KillActiveTab,
+            terminalStrings.kill.short,
+            ThemeIcon.asClassName(Codicon.trashcan),
+            true,
+            async () => {
+                this._runForSelectionOrInstance(instance, e => this._terminalService.safeDisposeTerminal(e));
+            }
+        ))));
+        template.actionBar.clear();
+        for (const action of actions) {
+            template.actionBar.push(action, { icon: true, label: false, keybinding: this._keybindingService.lookupKeybinding(action.id)?.getLabel() });
+        }
+    }
+    _runForSelectionOrInstance(instance, callback) {
+        const selection = this._getSelection();
+        if (selection.includes(instance)) {
+            for (const s of selection) {
+                if (s) {
+                    callback(s);
+                }
+            }
+        }
+        else {
+            callback(instance);
+        }
+        this._terminalGroupService.focusTabs();
+        this._listService.lastFocusedList?.focusNext();
+    }
+};
+TerminalTabsRenderer = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ITerminalConfigurationService)),
+    ( __param(5, ITerminalService)),
+    ( __param(6, ITerminalGroupService)),
+    ( __param(7, ITerminalEditingService)),
+    ( __param(8, IHoverService)),
+    ( __param(9, IKeybindingService)),
+    ( __param(10, IListService)),
+    ( __param(11, IStorageService)),
+    ( __param(12, IThemeService)),
+    ( __param(13, IContextViewService)),
+    ( __param(14, ICommandService))
+], TerminalTabsRenderer));
+let TerminalTabsAccessibilityProvider = class TerminalTabsAccessibilityProvider {
+    constructor(_terminalGroupService) {
+        this._terminalGroupService = _terminalGroupService;
+    }
+    getWidgetAriaLabel() {
+        return localize(11630, "Terminal tabs");
+    }
+    getAriaLabel(instance) {
+        let ariaLabel = '';
+        const tab = this._terminalGroupService.getGroupForInstance(instance);
+        if (tab && tab.terminalInstances?.length > 1) {
+            const terminalIndex = tab.terminalInstances.indexOf(instance);
+            ariaLabel = ( localize(
+                11631,
+                "Terminal {0} {1}, split {2} of {3}",
+                instance.instanceId,
+                instance.title,
+                terminalIndex + 1,
+                tab.terminalInstances.length
+            ));
+        }
+        else {
+            ariaLabel = ( localize(11632, "Terminal {0} {1}", instance.instanceId, instance.title));
+        }
+        return ariaLabel;
+    }
+};
+TerminalTabsAccessibilityProvider = ( __decorate([
+    ( __param(0, ITerminalGroupService))
+], TerminalTabsAccessibilityProvider));
+let TerminalTabsDragAndDrop = class TerminalTabsDragAndDrop extends Disposable {
+    constructor(_terminalService, _terminalGroupService, _terminalEditingService, _listService) {
+        super();
+        this._terminalService = _terminalService;
+        this._terminalGroupService = _terminalGroupService;
+        this._terminalEditingService = _terminalEditingService;
+        this._listService = _listService;
+        this._autoFocusDisposable = Disposable.None;
+        this._primaryBackend = this._terminalService.getPrimaryBackend();
+    }
+    getDragURI(instance) {
+        if (this._terminalEditingService.getEditingTerminal()?.instanceId === instance.instanceId) {
+            return null;
+        }
+        return ( instance.resource.toString());
+    }
+    getDragLabel(elements, originalEvent) {
+        return elements.length === 1 ? elements[0].title : undefined;
+    }
+    onDragLeave() {
+        this._autoFocusInstance = undefined;
+        this._autoFocusDisposable.dispose();
+        this._autoFocusDisposable = Disposable.None;
+    }
+    onDragStart(data, originalEvent) {
+        if (!originalEvent.dataTransfer) {
+            return;
+        }
+        const dndData = data.getData();
+        if (!Array.isArray(dndData)) {
+            return;
+        }
+        const terminals = dndData.filter(isTerminalInstance);
+        if (terminals.length > 0) {
+            originalEvent.dataTransfer.setData(TerminalDataTransfers.Terminals, JSON.stringify(( terminals.map(e => ( e.resource.toString())))));
+        }
+    }
+    onDragOver(data, targetInstance, targetIndex, targetSector, originalEvent) {
+        if (data instanceof NativeDragAndDropData) {
+            if (!containsDragType(originalEvent, DataTransfers.FILES, DataTransfers.RESOURCES, TerminalDataTransfers.Terminals, CodeDataTransfers.FILES)) {
+                return false;
+            }
+        }
+        const didChangeAutoFocusInstance = this._autoFocusInstance !== targetInstance;
+        if (didChangeAutoFocusInstance) {
+            this._autoFocusDisposable.dispose();
+            this._autoFocusInstance = targetInstance;
+        }
+        if (!targetInstance && !containsDragType(originalEvent, TerminalDataTransfers.Terminals)) {
+            return data instanceof ElementsDragAndDropData;
+        }
+        if (didChangeAutoFocusInstance && targetInstance) {
+            this._autoFocusDisposable = disposableTimeout(() => {
+                this._terminalService.setActiveInstance(targetInstance);
+                this._autoFocusInstance = undefined;
+            }, 500, this._store);
+        }
+        return {
+            feedback: targetIndex ? [targetIndex] : undefined,
+            accept: true,
+            effect: { type: ListDragOverEffectType.Move, position: ListDragOverEffectPosition.Over }
+        };
+    }
+    async drop(data, targetInstance, targetIndex, targetSector, originalEvent) {
+        this._autoFocusDisposable.dispose();
+        this._autoFocusInstance = undefined;
+        let sourceInstances;
+        const promises = [];
+        const resources = getTerminalResourcesFromDragEvent(originalEvent);
+        if (resources) {
+            for (const uri of resources) {
+                const instance = this._terminalService.getInstanceFromResource(uri);
+                if (instance) {
+                    if (Array.isArray(sourceInstances)) {
+                        sourceInstances.push(instance);
+                    }
+                    else {
+                        sourceInstances = [instance];
+                    }
+                    this._terminalService.moveToTerminalView(instance);
+                }
+                else if (this._primaryBackend) {
+                    const terminalIdentifier = parseTerminalUri(uri);
+                    if (terminalIdentifier.instanceId) {
+                        promises.push(this._primaryBackend.requestDetachInstance(terminalIdentifier.workspaceId, terminalIdentifier.instanceId));
+                    }
+                }
+            }
+        }
+        if (promises.length) {
+            let processes = await Promise.all(promises);
+            processes = processes.filter(p => p !== undefined);
+            let lastInstance;
+            for (const attachPersistentProcess of processes) {
+                lastInstance = await this._terminalService.createTerminal({ config: { attachPersistentProcess } });
+            }
+            if (lastInstance) {
+                this._terminalService.setActiveInstance(lastInstance);
+            }
+            return;
+        }
+        if (sourceInstances === undefined) {
+            if (!(data instanceof ElementsDragAndDropData)) {
+                this._handleExternalDrop(targetInstance, originalEvent);
+                return;
+            }
+            const draggedElement = data.getData();
+            if (!draggedElement || !Array.isArray(draggedElement)) {
+                return;
+            }
+            sourceInstances = [];
+            for (const e of draggedElement) {
+                if (isTerminalInstance(e)) {
+                    sourceInstances.push(e);
+                }
+            }
+        }
+        if (!targetInstance) {
+            this._terminalGroupService.moveGroupToEnd(sourceInstances);
+            this._terminalService.setActiveInstance(sourceInstances[0]);
+            const targetGroup = this._terminalGroupService.getGroupForInstance(sourceInstances[0]);
+            if (targetGroup) {
+                const index = this._terminalGroupService.groups.indexOf(targetGroup);
+                this._listService.lastFocusedList?.setSelection([index]);
+            }
+            return;
+        }
+        this._terminalGroupService.moveGroup(sourceInstances, targetInstance);
+        this._terminalService.setActiveInstance(sourceInstances[0]);
+        const targetGroup = this._terminalGroupService.getGroupForInstance(sourceInstances[0]);
+        if (targetGroup) {
+            const index = this._terminalGroupService.groups.indexOf(targetGroup);
+            this._listService.lastFocusedList?.setSelection([index]);
+        }
+    }
+    async _handleExternalDrop(instance, e) {
+        if (!instance || !e.dataTransfer) {
+            return;
+        }
+        let resource;
+        const rawResources = e.dataTransfer.getData(DataTransfers.RESOURCES);
+        if (rawResources) {
+            resource = ( URI.parse(JSON.parse(rawResources)[0]));
+        }
+        const rawCodeFiles = e.dataTransfer.getData(CodeDataTransfers.FILES);
+        if (!resource && rawCodeFiles) {
+            resource = URI.file(JSON.parse(rawCodeFiles)[0]);
+        }
+        if (!resource && e.dataTransfer.files.length > 0 && getPathForFile(e.dataTransfer.files[0])) {
+            resource = URI.file(getPathForFile(e.dataTransfer.files[0]));
+        }
+        if (!resource) {
+            return;
+        }
+        this._terminalService.setActiveInstance(instance);
+        instance.focus();
+        await instance.sendPath(resource, false);
+    }
+};
+TerminalTabsDragAndDrop = ( __decorate([
+    ( __param(0, ITerminalService)),
+    ( __param(1, ITerminalGroupService)),
+    ( __param(2, ITerminalEditingService)),
+    ( __param(3, IListService))
+], TerminalTabsDragAndDrop));
+let TabDecorationsProvider = class TabDecorationsProvider extends Disposable {
+    constructor(_terminalService) {
+        super();
+        this._terminalService = _terminalService;
+        this.label = ( localize(11633, "Terminal"));
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(this._terminalService.onAnyInstancePrimaryStatusChange(e => this._onDidChange.fire([e.resource])));
+    }
+    provideDecorations(resource) {
+        if (resource.scheme !== Schemas.vscodeTerminal) {
+            return undefined;
+        }
+        const instance = this._terminalService.getInstanceFromResource(resource);
+        if (!instance) {
+            return undefined;
+        }
+        const primaryStatus = instance?.statusList?.primary;
+        if (!primaryStatus?.icon) {
+            return undefined;
+        }
+        return {
+            color: getColorForSeverity(primaryStatus.severity),
+            letter: primaryStatus.icon,
+            tooltip: primaryStatus.tooltip
+        };
+    }
+};
+TabDecorationsProvider = ( __decorate([
+    ( __param(0, ITerminalService))
+], TabDecorationsProvider));
+function isTerminalInstance(obj) {
+    return isObject(obj) && 'instanceId' in obj;
+}
+
+export { TerminalTabList, TerminalTabsListSizes };