@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,598 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { switchTerminalActionViewItemSeparator, switchTerminalShowTabsTitle } from './terminalActions.js';
-import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { ITerminalService, ITerminalGroupService } from './terminal.js';
-import { ViewPane } from '../../../browser/parts/views/viewPane.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IViewDescriptorService } from '../../../common/views.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { MenuId, MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { ITerminalProfileResolverService, ITerminalProfileService } from '../common/terminal.js';
-import { TerminalLocation } from '../../../../platform/terminal/common/terminal.js';
-import { ActionViewItem, SelectActionViewItem } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionViewItems.js';
-import { asCssVariable, selectBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { TerminalTabbedView } from './terminalTabbedView.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
-import { getColorForSeverity } from './terminalStatusList.js';
-import { createAndFillInContextMenuActions, MenuEntryActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { DropdownWithPrimaryActionViewItem } from '../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
-import { toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
-import { getColorClass, getUriClasses } from './terminalIcon.js';
-import { getTerminalActionBarArgs } from './terminalMenus.js';
-import { TerminalContextKeys } from '../common/terminalContextKey.js';
-import { getInstanceHoverInfo } from './terminalTooltip.js';
-import { defaultSelectBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { IHoverService } from '../../../services/hover/browser/hover.js';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-let TerminalViewPane = class TerminalViewPane extends ViewPane {
-    get terminalTabbedView() { return this._terminalTabbedView; }
-    constructor(options, keybindingService, _contextKeyService, viewDescriptorService, _configurationService, _contextMenuService, _instantiationService, _terminalService, _terminalGroupService, themeService, telemetryService, _notificationService, _keybindingService, openerService, _menuService, _terminalProfileService, _terminalProfileResolverService, _themeService, _accessibilityService) {
-        super(options, keybindingService, _contextMenuService, _configurationService, _contextKeyService, viewDescriptorService, _instantiationService, openerService, themeService, telemetryService);
-        this._contextKeyService = _contextKeyService;
-        this._configurationService = _configurationService;
-        this._contextMenuService = _contextMenuService;
-        this._instantiationService = _instantiationService;
-        this._terminalService = _terminalService;
-        this._terminalGroupService = _terminalGroupService;
-        this._notificationService = _notificationService;
-        this._keybindingService = _keybindingService;
-        this._menuService = _menuService;
-        this._terminalProfileService = _terminalProfileService;
-        this._terminalProfileResolverService = _terminalProfileResolverService;
-        this._themeService = _themeService;
-        this._accessibilityService = _accessibilityService;
-        this._isWelcomeShowing = false;
-        this._isInitialized = false;
-        this._register(this._terminalService.onDidRegisterProcessSupport(() => {
-            this._onDidChangeViewWelcomeState.fire();
-        }));
-        this._register(this._terminalService.onDidChangeInstances(() => {
-            if (!this._isWelcomeShowing) {
-                return;
-            }
-            this._isWelcomeShowing = true;
-            this._onDidChangeViewWelcomeState.fire();
-            if (!this._terminalTabbedView && this._parentDomElement) {
-                this._createTabsView();
-                this.layoutBody(this._parentDomElement.offsetHeight, this._parentDomElement.offsetWidth);
-            }
-        }));
-        this._dropdownMenu = this._register(this._menuService.createMenu(MenuId.TerminalNewDropdownContext, this._contextKeyService));
-        this._singleTabMenu = this._register(this._menuService.createMenu(MenuId.TerminalTabContext, this._contextKeyService));
-        this._register(this._terminalProfileService.onDidChangeAvailableProfiles(profiles => this._updateTabActionBar(profiles)));
-        this._viewShowing = TerminalContextKeys.viewShowing.bindTo(this._contextKeyService);
-        this._register(this.onDidChangeBodyVisibility(e => {
-            if (e) {
-                this._terminalTabbedView?.rerenderTabs();
-            }
-        }));
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (this._parentDomElement && (e.affectsConfiguration("terminal.integrated.shellIntegration.decorationsEnabled" ) || e.affectsConfiguration("terminal.integrated.shellIntegration.enabled" ))) {
-                this._updateForShellIntegration(this._parentDomElement);
-            }
-        }));
-        this._register(this._terminalService.onDidCreateInstance((i) => {
-            i.capabilities.onDidAddCapabilityType(c => {
-                if (c === 2  && this._gutterDecorationsEnabled()) {
-                    this._parentDomElement?.classList.add('shell-integration');
-                }
-            });
-        }));
-    }
-    _updateForShellIntegration(container) {
-        container.classList.toggle('shell-integration', this._gutterDecorationsEnabled());
-    }
-    _gutterDecorationsEnabled() {
-        const decorationsEnabled = this._configurationService.getValue("terminal.integrated.shellIntegration.decorationsEnabled" );
-        return (decorationsEnabled === 'both' || decorationsEnabled === 'gutter') && this._configurationService.getValue("terminal.integrated.shellIntegration.enabled" );
-    }
-    _initializeTerminal(checkRestoredTerminals) {
-        if (this.isBodyVisible() && this._terminalService.isProcessSupportRegistered && this._terminalService.connectionState === 1 ) {
-            const wasInitialized = this._isInitialized;
-            this._isInitialized = true;
-            let hideOnStartup = 'never';
-            if (!wasInitialized) {
-                hideOnStartup = this._configurationService.getValue("terminal.integrated.hideOnStartup" );
-                if (hideOnStartup === 'always') {
-                    this._terminalGroupService.hidePanel();
-                }
-            }
-            let shouldCreate = this._terminalGroupService.groups.length === 0;
-            if (checkRestoredTerminals) {
-                shouldCreate &&= this._terminalService.restoredGroupCount === 0;
-            }
-            if (!shouldCreate) {
-                return;
-            }
-            if (!wasInitialized) {
-                switch (hideOnStartup) {
-                    case 'never':
-                        this._terminalService.createTerminal({ location: TerminalLocation.Panel });
-                        break;
-                    case 'whenEmpty':
-                        if (this._terminalService.restoredGroupCount === 0) {
-                            this._terminalGroupService.hidePanel();
-                        }
-                        break;
-                }
-                return;
-            }
-            this._terminalService.createTerminal({ location: TerminalLocation.Panel });
-        }
-    }
-    renderBody(container) {
-        super.renderBody(container);
-        if (!this._parentDomElement) {
-            this._updateForShellIntegration(container);
-        }
-        this._parentDomElement = container;
-        this._parentDomElement.classList.add('integrated-terminal');
-        this._fontStyleElement = document.createElement('style');
-        this._instantiationService.createInstance(TerminalThemeIconStyle, this._parentDomElement);
-        if (!this.shouldShowWelcome()) {
-            this._createTabsView();
-        }
-        this._parentDomElement.appendChild(this._fontStyleElement);
-        this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration("terminal.integrated.fontFamily" ) || e.affectsConfiguration('editor.fontFamily')) {
-                const configHelper = this._terminalService.configHelper;
-                if (!configHelper.configFontIsMonospace()) {
-                    const choices = [{
-                            label: ( nls.localize('terminal.useMonospace', "Use 'monospace'")),
-                            run: () => this.configurationService.updateValue("terminal.integrated.fontFamily" , 'monospace'),
-                        }];
-                    this._notificationService.prompt(Severity.Warning, ( nls.localize(
-                        'terminal.monospaceOnly',
-                        "The terminal only supports monospace fonts. Be sure to restart VS Code if this is a newly installed font."
-                    )), choices);
-                }
-            }
-        }));
-        this._register(this.onDidChangeBodyVisibility(async (visible) => {
-            this._viewShowing.set(visible);
-            if (visible) {
-                if (!this._terminalService.isProcessSupportRegistered) {
-                    this._onDidChangeViewWelcomeState.fire();
-                }
-                this._initializeTerminal(false);
-                this._terminalGroupService.showPanel(false);
-            }
-            else {
-                for (const instance of this._terminalGroupService.instances) {
-                    instance.resetFocusContextKey();
-                }
-            }
-            this._terminalGroupService.updateVisibility();
-        }));
-        this._register(this._terminalService.onDidChangeConnectionState(() => this._initializeTerminal(true)));
-        this.layoutBody(this._parentDomElement.offsetHeight, this._parentDomElement.offsetWidth);
-    }
-    _createTabsView() {
-        if (!this._parentDomElement) {
-            return;
-        }
-        this._terminalTabbedView = this.instantiationService.createInstance(TerminalTabbedView, this._parentDomElement);
-    }
-    layoutBody(height, width) {
-        super.layoutBody(height, width);
-        this._terminalTabbedView?.layout(width, height);
-    }
-    getActionViewItem(action) {
-        switch (action.id) {
-            case "workbench.action.terminal.split" : {
-                const that = this;
-                const panelOnlySplitAction = new (class extends Action {
-                    constructor() {
-                        super(action.id, action.label, action.class, action.enabled);
-                        this.checked = action.checked;
-                        this.tooltip = action.tooltip;
-                    }
-                    dispose() {
-                        action.dispose();
-                    }
-                    async run() {
-                        const instance = that._terminalGroupService.activeInstance;
-                        if (instance) {
-                            const newInstance = await that._terminalService.createTerminal({ location: { parentTerminal: instance } });
-                            return newInstance?.focusWhenReady();
-                        }
-                        return;
-                    }
-                });
-                return ( new ActionViewItem(
-                    action,
-                    panelOnlySplitAction,
-                    { icon: true, label: false, keybinding: this._getKeybindingLabel(action) }
-                ));
-            }
-            case "workbench.action.terminal.switchTerminal" : {
-                return this._instantiationService.createInstance(SwitchTerminalActionViewItem, action);
-            }
-            case "workbench.action.terminal.focus" : {
-                if (action instanceof MenuItemAction) {
-                    const actions = [];
-                    createAndFillInContextMenuActions(this._singleTabMenu, undefined, actions);
-                    return this._instantiationService.createInstance(SingleTerminalTabActionViewItem, action, actions);
-                }
-            }
-            case "workbench.action.terminal.new" : {
-                if (action instanceof MenuItemAction) {
-                    const actions = getTerminalActionBarArgs(TerminalLocation.Panel, this._terminalProfileService.availableProfiles, this._getDefaultProfileName(), this._terminalProfileService.contributedProfiles, this._terminalService, this._dropdownMenu);
-                    this._newDropdown?.dispose();
-                    this._newDropdown = ( new DropdownWithPrimaryActionViewItem(
-                        action,
-                        actions.dropdownAction,
-                        actions.dropdownMenuActions,
-                        actions.className,
-                        this._contextMenuService,
-                        {},
-                        this._keybindingService,
-                        this._notificationService,
-                        this._contextKeyService,
-                        this._themeService,
-                        this._accessibilityService
-                    ));
-                    this._updateTabActionBar(this._terminalProfileService.availableProfiles);
-                    return this._newDropdown;
-                }
-            }
-        }
-        return super.getActionViewItem(action);
-    }
-    _getDefaultProfileName() {
-        let defaultProfileName;
-        try {
-            defaultProfileName = this._terminalProfileService.getDefaultProfileName();
-        }
-        catch (e) {
-            defaultProfileName = this._terminalProfileResolverService.defaultProfileName;
-        }
-        return defaultProfileName;
-    }
-    _getKeybindingLabel(action) {
-        return this._keybindingService.lookupKeybinding(action.id)?.getLabel() ?? undefined;
-    }
-    _updateTabActionBar(profiles) {
-        const actions = getTerminalActionBarArgs(TerminalLocation.Panel, profiles, this._getDefaultProfileName(), this._terminalProfileService.contributedProfiles, this._terminalService, this._dropdownMenu);
-        this._newDropdown?.update(actions.dropdownAction, actions.dropdownMenuActions);
-    }
-    focus() {
-        if (this._terminalService.connectionState === 0 ) {
-            const activeElement = document.activeElement;
-            this._register(this._terminalService.onDidChangeConnectionState(() => {
-                if (document.activeElement === activeElement) {
-                    this._terminalGroupService.showPanel(true);
-                }
-            }));
-            return;
-        }
-        this._terminalGroupService.showPanel(true);
-    }
-    shouldShowWelcome() {
-        this._isWelcomeShowing = !this._terminalService.isProcessSupportRegistered && this._terminalService.instances.length === 0;
-        return this._isWelcomeShowing;
-    }
-};
-TerminalViewPane = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IViewDescriptorService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, ITerminalService)),
-    ( __param(8, ITerminalGroupService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, ITelemetryService)),
-    ( __param(11, INotificationService)),
-    ( __param(12, IKeybindingService)),
-    ( __param(13, IOpenerService)),
-    ( __param(14, IMenuService)),
-    ( __param(15, ITerminalProfileService)),
-    ( __param(16, ITerminalProfileResolverService)),
-    ( __param(17, IThemeService)),
-    ( __param(18, IAccessibilityService))
-], TerminalViewPane));
-let SwitchTerminalActionViewItem = class SwitchTerminalActionViewItem extends SelectActionViewItem {
-    constructor(action, _terminalService, _terminalGroupService, contextViewService, terminalProfileService) {
-        super(null, action, getTerminalSelectOpenItems(_terminalService, _terminalGroupService), _terminalGroupService.activeGroupIndex, contextViewService, defaultSelectBoxStyles, { ariaLabel: ( nls.localize('terminals', 'Open Terminals.')), optionsAsChildren: true });
-        this._terminalService = _terminalService;
-        this._terminalGroupService = _terminalGroupService;
-        this._register(_terminalService.onDidChangeInstances(() => this._updateItems(), this));
-        this._register(_terminalService.onDidChangeActiveGroup(() => this._updateItems(), this));
-        this._register(_terminalService.onDidChangeActiveInstance(() => this._updateItems(), this));
-        this._register(_terminalService.onDidChangeInstanceTitle(() => this._updateItems(), this));
-        this._register(_terminalGroupService.onDidChangeGroups(() => this._updateItems(), this));
-        this._register(_terminalService.onDidChangeConnectionState(() => this._updateItems(), this));
-        this._register(terminalProfileService.onDidChangeAvailableProfiles(() => this._updateItems(), this));
-        this._register(_terminalService.onDidChangeInstancePrimaryStatus(() => this._updateItems(), this));
-    }
-    render(container) {
-        super.render(container);
-        container.classList.add('switch-terminal');
-        container.style.borderColor = asCssVariable(selectBorder);
-    }
-    _updateItems() {
-        const options = getTerminalSelectOpenItems(this._terminalService, this._terminalGroupService);
-        this.setOptions(options, this._terminalGroupService.activeGroupIndex);
-    }
-};
-SwitchTerminalActionViewItem = ( __decorate([
-    ( __param(1, ITerminalService)),
-    ( __param(2, ITerminalGroupService)),
-    ( __param(3, IContextViewService)),
-    ( __param(4, ITerminalProfileService))
-], SwitchTerminalActionViewItem));
-function getTerminalSelectOpenItems(terminalService, terminalGroupService) {
-    let items;
-    if (terminalService.connectionState === 1 ) {
-        items = ( terminalGroupService.getGroupLabels().map(label => {
-            return { text: label };
-        }));
-    }
-    else {
-        items = [{ text: ( nls.localize('terminalConnectingLabel', "Starting...")) }];
-    }
-    items.push({ text: switchTerminalActionViewItemSeparator, isDisabled: true });
-    items.push({ text: switchTerminalShowTabsTitle });
-    return items;
-}
-let SingleTerminalTabActionViewItem = class SingleTerminalTabActionViewItem extends MenuEntryActionViewItem {
-    constructor(action, _actions, keybindingService, notificationService, contextKeyService, themeService, _terminalService, _terminalGroupService, contextMenuService, _commandService, _instantiationService, _accessibilityService) {
-        super(action, {
-            draggable: true,
-            hoverDelegate: _instantiationService.createInstance(SingleTabHoverDelegate)
-        }, keybindingService, notificationService, contextKeyService, themeService, contextMenuService, _accessibilityService);
-        this._actions = _actions;
-        this._terminalService = _terminalService;
-        this._terminalGroupService = _terminalGroupService;
-        this._commandService = _commandService;
-        this._instantiationService = _instantiationService;
-        this._elementDisposables = [];
-        this._register(Event.debounce(Event.any(this._terminalService.onDidChangeInstancePrimaryStatus, this._terminalGroupService.onDidChangeActiveInstance, ( Event.map(this._terminalService.onDidChangeInstanceIcon, e => e.instance)), ( Event.map(this._terminalService.onDidChangeInstanceColor, e => e.instance)), this._terminalService.onDidChangeInstanceTitle, this._terminalService.onDidChangeInstanceCapability), (last, e) => {
-            if (!last) {
-                last = ( new Set());
-            }
-            if (e) {
-                last.add(e);
-            }
-            return last;
-        })(merged => {
-            for (const e of merged) {
-                this.updateLabel(e);
-            }
-        }));
-        this._register(toDisposable(() => dispose(this._elementDisposables)));
-    }
-    async onClick(event) {
-        this._terminalGroupService.lastAccessedMenu = 'inline-tab';
-        if (event.altKey && this._menuItemAction.alt) {
-            this._commandService.executeCommand(this._menuItemAction.alt.id, { target: TerminalLocation.Panel });
-        }
-        else {
-            this._openContextMenu();
-        }
-    }
-    updateLabel(e) {
-        if (e && e !== this._terminalGroupService.activeInstance) {
-            return;
-        }
-        if (this._elementDisposables.length === 0 && this.element && this.label) {
-            this._elementDisposables.push(dom.addDisposableListener(this.element, dom.EventType.CONTEXT_MENU, e => {
-                if (e.button === 2) {
-                    this._openContextMenu();
-                    e.preventDefault();
-                }
-            }));
-            this._elementDisposables.push(dom.addDisposableListener(this.element, dom.EventType.AUXCLICK, e => {
-                if (e.button === 1) {
-                    const instance = this._terminalGroupService.activeInstance;
-                    if (instance) {
-                        this._terminalService.safeDisposeTerminal(instance);
-                    }
-                    e.preventDefault();
-                }
-            }));
-            this._elementDisposables.push(dom.addDisposableListener(this.element, dom.EventType.DRAG_START, e => {
-                const instance = this._terminalGroupService.activeInstance;
-                if (e.dataTransfer && instance) {
-                    e.dataTransfer.setData("Terminals" , JSON.stringify([( instance.resource.toString())]));
-                }
-            }));
-        }
-        if (this.label) {
-            const label = this.label;
-            const instance = this._terminalGroupService.activeInstance;
-            if (!instance) {
-                dom.reset(label, '');
-                return;
-            }
-            label.classList.add('single-terminal-tab');
-            let colorStyle = '';
-            const primaryStatus = instance.statusList.primary;
-            if (primaryStatus) {
-                const colorKey = getColorForSeverity(primaryStatus.severity);
-                this._themeService.getColorTheme();
-                const foundColor = this._themeService.getColorTheme().getColor(colorKey);
-                if (foundColor) {
-                    colorStyle = ( foundColor.toString());
-                }
-            }
-            label.style.color = colorStyle;
-            dom.reset(label, ...renderLabelWithIcons(this._instantiationService.invokeFunction(getSingleTabLabel, instance, this._terminalService.configHelper.config.tabs.separator, ThemeIcon.isThemeIcon(this._commandAction.item.icon) ? this._commandAction.item.icon : undefined)));
-            if (this._altCommand) {
-                label.classList.remove(this._altCommand);
-                this._altCommand = undefined;
-            }
-            if (this._color) {
-                label.classList.remove(this._color);
-                this._color = undefined;
-            }
-            if (this._class) {
-                label.classList.remove(this._class);
-                label.classList.remove('terminal-uri-icon');
-                this._class = undefined;
-            }
-            const colorClass = getColorClass(instance);
-            if (colorClass) {
-                this._color = colorClass;
-                label.classList.add(colorClass);
-            }
-            const uriClasses = getUriClasses(instance, this._themeService.getColorTheme().type);
-            if (uriClasses) {
-                this._class = uriClasses?.[0];
-                label.classList.add(...uriClasses);
-            }
-            if (this._commandAction.item.icon) {
-                this._altCommand = `alt-command`;
-                label.classList.add(this._altCommand);
-            }
-            this.updateTooltip();
-        }
-    }
-    _openContextMenu() {
-        this._contextMenuService.showContextMenu({
-            getAnchor: () => this.element,
-            getActions: () => this._actions,
-            getActionsContext: () => this.label
-        });
-    }
-};
-SingleTerminalTabActionViewItem = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, ITerminalService)),
-    ( __param(7, ITerminalGroupService)),
-    ( __param(8, IContextMenuService)),
-    ( __param(9, ICommandService)),
-    ( __param(10, IInstantiationService)),
-    ( __param(11, IAccessibilityService))
-], SingleTerminalTabActionViewItem));
-function getSingleTabLabel(accessor, instance, separator, icon) {
-    if (!instance || !instance.title) {
-        return '';
-    }
-    const iconId = ThemeIcon.isThemeIcon(instance.icon) ? instance.icon.id : accessor.get(ITerminalProfileResolverService).getDefaultIcon().id;
-    const label = `$(${icon?.id || iconId}) ${getSingleTabTitle(instance, separator)}`;
-    const primaryStatus = instance.statusList.primary;
-    if (!primaryStatus?.icon) {
-        return label;
-    }
-    return `${label} $(${primaryStatus.icon.id})`;
-}
-function getSingleTabTitle(instance, separator) {
-    if (!instance) {
-        return '';
-    }
-    return !instance.description ? instance.title : `${instance.title} ${separator} ${instance.description}`;
-}
-let TerminalThemeIconStyle = class TerminalThemeIconStyle extends Themable {
-    constructor(container, _themeService, _terminalService, _terminalGroupService) {
-        super(_themeService);
-        this._themeService = _themeService;
-        this._terminalService = _terminalService;
-        this._terminalGroupService = _terminalGroupService;
-        this._registerListeners();
-        this._styleElement = document.createElement('style');
-        container.appendChild(this._styleElement);
-        this._register(toDisposable(() => container.removeChild(this._styleElement)));
-        this.updateStyles();
-    }
-    _registerListeners() {
-        this._register(this._terminalService.onDidChangeInstanceIcon(() => this.updateStyles()));
-        this._register(this._terminalService.onDidChangeInstanceColor(() => this.updateStyles()));
-        this._register(this._terminalService.onDidChangeInstances(() => this.updateStyles()));
-        this._register(this._terminalGroupService.onDidChangeGroups(() => this.updateStyles()));
-    }
-    updateStyles() {
-        super.updateStyles();
-        const colorTheme = this._themeService.getColorTheme();
-        let css = '';
-        for (const instance of this._terminalService.instances) {
-            const icon = instance.icon;
-            if (!icon) {
-                continue;
-            }
-            let uri = undefined;
-            if (icon instanceof URI) {
-                uri = icon;
-            }
-            else if (icon instanceof Object && 'light' in icon && 'dark' in icon) {
-                uri = colorTheme.type === ColorScheme.LIGHT ? icon.light : icon.dark;
-            }
-            const iconClasses = getUriClasses(instance, colorTheme.type);
-            if (uri instanceof URI && iconClasses && iconClasses.length > 1) {
-                css += (`.monaco-workbench .${iconClasses[0]} .monaco-highlighted-label .codicon, .monaco-action-bar .terminal-uri-icon.single-terminal-tab.action-label:not(.alt-command) .codicon` +
-                    `{background-image: ${dom.asCSSUrl(uri)};}`);
-            }
-        }
-        for (const instance of this._terminalService.instances) {
-            const colorClass = getColorClass(instance);
-            if (!colorClass || !instance.color) {
-                continue;
-            }
-            const color = colorTheme.getColor(instance.color);
-            if (color) {
-                css += (`.monaco-workbench .${colorClass} .codicon:first-child:not(.codicon-split-horizontal):not(.codicon-trashcan):not(.file-icon)` +
-                    `{ color: ${color} !important; }`);
-            }
-        }
-        this._styleElement.textContent = css;
-    }
-};
-TerminalThemeIconStyle = ( __decorate([
-    ( __param(1, IThemeService)),
-    ( __param(2, ITerminalService)),
-    ( __param(3, ITerminalGroupService))
-], TerminalThemeIconStyle));
-let SingleTabHoverDelegate = class SingleTabHoverDelegate {
-    constructor(_configurationService, _hoverService, _terminalGroupService) {
-        this._configurationService = _configurationService;
-        this._hoverService = _hoverService;
-        this._terminalGroupService = _terminalGroupService;
-        this._lastHoverHideTime = 0;
-        this.placement = 'element';
-    }
-    get delay() {
-        return Date.now() - this._lastHoverHideTime < 200
-            ? 0
-            : this._configurationService.getValue('workbench.hover.delay');
-    }
-    showHover(options, focus) {
-        const instance = this._terminalGroupService.activeInstance;
-        if (!instance) {
-            return;
-        }
-        const hoverInfo = getInstanceHoverInfo(instance);
-        return this._hoverService.showHover({
-            ...options,
-            content: hoverInfo.content,
-            actions: hoverInfo.actions
-        }, focus);
-    }
-    onDidHideHover() {
-        this._lastHoverHideTime = Date.now();
-    }
-};
-SingleTabHoverDelegate = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IHoverService)),
-    ( __param(2, ITerminalGroupService))
-], SingleTabHoverDelegate));
-export { TerminalViewPane };

package/vscode/src/vs/workbench/contrib/terminal/browser/widgets/widgetManager.js

@@ -1,36 +0,0 @@
-class TerminalWidgetManager {
-    constructor() {
-        this._attached = ( new Map());
-    }
-    attachToElement(terminalWrapper) {
-        if (!this._container) {
-            this._container = document.createElement('div');
-            this._container.classList.add('terminal-widget-container');
-            terminalWrapper.appendChild(this._container);
-        }
-    }
-    dispose() {
-        if (this._container && this._container.parentElement) {
-            this._container.parentElement.removeChild(this._container);
-            this._container = undefined;
-        }
-    }
-    attachWidget(widget) {
-        if (!this._container) {
-            return;
-        }
-        this._attached.get(widget.id)?.dispose();
-        widget.attach(this._container);
-        this._attached.set(widget.id, widget);
-        return {
-            dispose: () => {
-                const current = this._attached.get(widget.id);
-                if (current === widget) {
-                    this._attached.delete(widget.id);
-                    widget.dispose();
-                }
-            }
-        };
-    }
-}
-export { TerminalWidgetManager };