@codingame/monaco-vscode-api 9.0.2 → 10.0.0

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

@@ -0,0 +1,143 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../../nls.js';
+import { PickerQuickAccessProvider, TriggerAction } from '../../../../platform/quickinput/browser/pickerQuickAccess.js';
+import { matchesFuzzy } from '../../../../base/common/filters.js';
+import { ITerminalService, ITerminalEditorService, ITerminalGroupService } from './terminal.service.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { renameTerminalIcon, killTerminalIcon } from './terminalIcons.js';
+import { getIconId, getColorClass, getUriClasses } from './terminalIcon.js';
+import { terminalStrings } from '../common/terminalStrings.js';
+import { TerminalLocation } from '../../../../platform/terminal/common/terminal.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+var TerminalQuickAccessProvider_1;
+let terminalPicks = [];
+let TerminalQuickAccessProvider = class TerminalQuickAccessProvider extends PickerQuickAccessProvider {
+    static { TerminalQuickAccessProvider_1 = this; }
+    static { this.PREFIX = 'term '; }
+    constructor(_editorService, _terminalService, _terminalEditorService, _terminalGroupService, _commandService, _themeService, _instantiationService) {
+        super(TerminalQuickAccessProvider_1.PREFIX, { canAcceptInBackground: true });
+        this._editorService = _editorService;
+        this._terminalService = _terminalService;
+        this._terminalEditorService = _terminalEditorService;
+        this._terminalGroupService = _terminalGroupService;
+        this._commandService = _commandService;
+        this._themeService = _themeService;
+        this._instantiationService = _instantiationService;
+    }
+    _getPicks(filter) {
+        terminalPicks = [];
+        terminalPicks.push({ type: 'separator', label: 'panel' });
+        const terminalGroups = this._terminalGroupService.groups;
+        for (let groupIndex = 0; groupIndex < terminalGroups.length; groupIndex++) {
+            const terminalGroup = terminalGroups[groupIndex];
+            for (let terminalIndex = 0; terminalIndex < terminalGroup.terminalInstances.length; terminalIndex++) {
+                const terminal = terminalGroup.terminalInstances[terminalIndex];
+                const pick = this._createPick(terminal, terminalIndex, filter, { groupIndex, groupSize: terminalGroup.terminalInstances.length });
+                if (pick) {
+                    terminalPicks.push(pick);
+                }
+            }
+        }
+        if (terminalPicks.length > 0) {
+            terminalPicks.push({ type: 'separator', label: 'editor' });
+        }
+        const terminalEditors = this._terminalEditorService.instances;
+        for (let editorIndex = 0; editorIndex < terminalEditors.length; editorIndex++) {
+            const term = terminalEditors[editorIndex];
+            term.target = TerminalLocation.Editor;
+            const pick = this._createPick(term, editorIndex, filter);
+            if (pick) {
+                terminalPicks.push(pick);
+            }
+        }
+        if (terminalPicks.length > 0) {
+            terminalPicks.push({ type: 'separator' });
+        }
+        const createTerminalLabel = ( localize(9145, "Create New Terminal"));
+        terminalPicks.push({
+            label: `$(plus) ${createTerminalLabel}`,
+            ariaLabel: createTerminalLabel,
+            accept: () => this._commandService.executeCommand("workbench.action.terminal.new" )
+        });
+        const createWithProfileLabel = ( localize(9146, "Create New Terminal With Profile..."));
+        terminalPicks.push({
+            label: `$(plus) ${createWithProfileLabel}`,
+            ariaLabel: createWithProfileLabel,
+            accept: () => this._commandService.executeCommand("workbench.action.terminal.newWithProfile" )
+        });
+        return terminalPicks;
+    }
+    _createPick(terminal, terminalIndex, filter, groupInfo) {
+        const iconId = this._instantiationService.invokeFunction(getIconId, terminal);
+        const index = groupInfo
+            ? (groupInfo.groupSize > 1
+                ? `${groupInfo.groupIndex + 1}.${terminalIndex + 1}`
+                : `${groupInfo.groupIndex + 1}`)
+            : `${terminalIndex + 1}`;
+        const label = `$(${iconId}) ${index}: ${terminal.title}`;
+        const iconClasses = [];
+        const colorClass = getColorClass(terminal);
+        if (colorClass) {
+            iconClasses.push(colorClass);
+        }
+        const uriClasses = getUriClasses(terminal, this._themeService.getColorTheme().type);
+        if (uriClasses) {
+            iconClasses.push(...uriClasses);
+        }
+        const highlights = matchesFuzzy(filter, label, true);
+        if (highlights) {
+            return {
+                label,
+                description: terminal.description,
+                highlights: { label: highlights },
+                buttons: [
+                    {
+                        iconClass: ThemeIcon.asClassName(renameTerminalIcon),
+                        tooltip: ( localize(9147, "Rename Terminal"))
+                    },
+                    {
+                        iconClass: ThemeIcon.asClassName(killTerminalIcon),
+                        tooltip: terminalStrings.kill.value
+                    }
+                ],
+                iconClasses,
+                trigger: buttonIndex => {
+                    switch (buttonIndex) {
+                        case 0:
+                            this._commandService.executeCommand("workbench.action.terminal.rename" , terminal);
+                            return TriggerAction.NO_ACTION;
+                        case 1:
+                            this._terminalService.safeDisposeTerminal(terminal);
+                            return TriggerAction.REMOVE_ITEM;
+                    }
+                    return TriggerAction.NO_ACTION;
+                },
+                accept: (keyMod, event) => {
+                    if (terminal.target === TerminalLocation.Editor) {
+                        const existingEditors = this._editorService.findEditors(terminal.resource);
+                        this._terminalEditorService.openEditor(terminal, { viewColumn: existingEditors?.[0].groupId });
+                        this._terminalEditorService.setActiveInstance(terminal);
+                    }
+                    else {
+                        this._terminalGroupService.showPanel(!event.inBackground);
+                        this._terminalGroupService.setActiveInstance(terminal);
+                    }
+                }
+            };
+        }
+        return undefined;
+    }
+};
+TerminalQuickAccessProvider = TerminalQuickAccessProvider_1 = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, ITerminalService))),
+    ( (__param(2, ITerminalEditorService))),
+    ( (__param(3, ITerminalGroupService))),
+    ( (__param(4, ICommandService))),
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IInstantiationService)))
+], TerminalQuickAccessProvider)));
+export { TerminalQuickAccessProvider };

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

@@ -0,0 +1,61 @@
+import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getWindow, runWhenWindowIdle } from '../../../../base/browser/dom.js';
+import { debounce } from '../../../../base/common/decorators.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+class TerminalResizeDebouncer extends Disposable {
+    constructor(_isVisible, _getXterm, _resizeBothCallback, _resizeXCallback, _resizeYCallback) {
+        super();
+        this._isVisible = _isVisible;
+        this._getXterm = _getXterm;
+        this._resizeBothCallback = _resizeBothCallback;
+        this._resizeXCallback = _resizeXCallback;
+        this._resizeYCallback = _resizeYCallback;
+        this._latestX = 0;
+        this._latestY = 0;
+        this._resizeXJob = this._register(( new MutableDisposable()));
+        this._resizeYJob = this._register(( new MutableDisposable()));
+    }
+    async resize(cols, rows, immediate) {
+        this._latestX = cols;
+        this._latestY = rows;
+        if (immediate || this._getXterm().raw.buffer.normal.length < 200 ) {
+            this._resizeXJob.clear();
+            this._resizeYJob.clear();
+            this._resizeBothCallback(cols, rows);
+            return;
+        }
+        const win = getWindow(this._getXterm().raw.element);
+        if (win && !this._isVisible()) {
+            if (!this._resizeXJob.value) {
+                this._resizeXJob.value = runWhenWindowIdle(win, async () => {
+                    this._resizeXCallback(this._latestX);
+                    this._resizeXJob.clear();
+                });
+            }
+            if (!this._resizeYJob.value) {
+                this._resizeYJob.value = runWhenWindowIdle(win, async () => {
+                    this._resizeYCallback(this._latestY);
+                    this._resizeYJob.clear();
+                });
+            }
+            return;
+        }
+        this._resizeYCallback(rows);
+        this._latestX = cols;
+        this._debounceResizeX(cols);
+    }
+    flush() {
+        if (this._resizeXJob.value || this._resizeYJob.value) {
+            this._resizeXJob.clear();
+            this._resizeYJob.clear();
+            this._resizeBothCallback(this._latestX, this._latestY);
+        }
+    }
+    _debounceResizeX(cols) {
+        this._resizeXCallback(cols);
+    }
+}
+TerminalResizeDebouncer.__decorator = ( __decorate([
+    debounce(100)
+], TerminalResizeDebouncer.prototype, "_debounceResizeX", null));
+export { TerminalResizeDebouncer };

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

@@ -0,0 +1,315 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Toggle } from '../../../../base/browser/ui/toggle/toggle.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { localize } from '../../../../nls.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
+import { collapseTildePath } from '../../../../platform/terminal/common/terminalEnvironment.js';
+import { asCssVariable } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import { inputActiveOptionBorder, inputActiveOptionForeground, inputActiveOptionBackground } from '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { commandHistoryRemoveIcon, commandHistoryOutputIcon, commandHistoryFuzzySearchIcon } from './terminalIcons.js';
+import { getCommandHistory, getShellFileHistory, getDirectoryHistory } from '../common/history.js';
+import { terminalStrings } from '../common/terminalStrings.js';
+import { URI } from '../../../../base/common/uri.js';
+import { fromNow } from '../../../../base/common/date.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { showWithPinnedItems } from '../../../../platform/quickinput/browser/quickPickPin.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { IAccessibleViewService } from '../../../../platform/accessibility/browser/accessibleView.service.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+var TerminalOutputProvider_1;
+async function showRunRecentQuickPick(accessor, instance, terminalInRunCommandPicker, type, filterMode, value) {
+    if (!instance.xterm) {
+        return;
+    }
+    const editorService = accessor.get(IEditorService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const quickInputService = accessor.get(IQuickInputService);
+    const storageService = accessor.get(IStorageService);
+    const accessibleViewService = accessor.get(IAccessibleViewService);
+    const runRecentStorageKey = `${"terminal.pinnedRecentCommands" }.${instance.shellType}`;
+    let placeholder;
+    let items = [];
+    const commandMap = ( (new Set()));
+    const removeFromCommandHistoryButton = {
+        iconClass: ThemeIcon.asClassName(commandHistoryRemoveIcon),
+        tooltip: ( localize(11149, "Remove from Command History"))
+    };
+    const commandOutputButton = {
+        iconClass: ThemeIcon.asClassName(commandHistoryOutputIcon),
+        tooltip: ( localize(11150, "View Command Output")),
+        alwaysVisible: false
+    };
+    if (type === 'command') {
+        placeholder = isMacintosh ? ( localize(11151, 'Select a command to run (hold Option-key to edit the command)')) : ( localize(11152, 'Select a command to run (hold Alt-key to edit the command)'));
+        const cmdDetection = instance.capabilities.get(2 );
+        const commands = cmdDetection?.commands;
+        const executingCommand = cmdDetection?.executingCommand;
+        if (executingCommand) {
+            commandMap.add(executingCommand);
+        }
+        function formatLabel(label) {
+            return label
+                .replace(/\r?\n/g, '\u23CE')
+                .replace(/\s\s\s+/g, '\u22EF');
+        }
+        if (commands && commands.length > 0) {
+            for (const entry of commands) {
+                const label = entry.command.trim();
+                if (label.length === 0 || ( (commandMap.has(label)))) {
+                    continue;
+                }
+                let description = collapseTildePath(entry.cwd, instance.userHome, instance.os === 1  ? '\\' : '/');
+                if (entry.exitCode) {
+                    if (entry.exitCode === -1) {
+                        description += ' failed';
+                    }
+                    else {
+                        description += ` exitCode: ${entry.exitCode}`;
+                    }
+                }
+                description = description.trim();
+                const buttons = [commandOutputButton];
+                const lastItem = items.length > 0 ? items[items.length - 1] : undefined;
+                if (lastItem?.type !== 'separator' && lastItem?.label === label) {
+                    lastItem.id = ( (entry.timestamp.toString()));
+                    lastItem.description = description;
+                    continue;
+                }
+                items.push({
+                    label: formatLabel(label),
+                    rawLabel: label,
+                    description,
+                    id: ( (entry.timestamp.toString())),
+                    command: entry,
+                    buttons: entry.hasOutput() ? buttons : undefined
+                });
+                commandMap.add(label);
+            }
+            items = items.reverse();
+        }
+        if (executingCommand) {
+            items.unshift({
+                label: formatLabel(executingCommand),
+                rawLabel: executingCommand,
+                description: cmdDetection.cwd
+            });
+        }
+        if (items.length > 0) {
+            items.unshift({ type: 'separator', label: terminalStrings.currentSessionCategory });
+        }
+        const history = instantiationService.invokeFunction(getCommandHistory);
+        const previousSessionItems = [];
+        for (const [label, info] of history.entries) {
+            if (!( (commandMap.has(label))) && info.shellType === instance.shellType) {
+                previousSessionItems.unshift({
+                    label: formatLabel(label),
+                    rawLabel: label,
+                    buttons: [removeFromCommandHistoryButton]
+                });
+                commandMap.add(label);
+            }
+        }
+        if (previousSessionItems.length > 0) {
+            items.push({ type: 'separator', label: terminalStrings.previousSessionCategory }, ...previousSessionItems);
+        }
+        const shellFileHistory = await instantiationService.invokeFunction(getShellFileHistory, instance.shellType);
+        const dedupedShellFileItems = [];
+        for (const label of shellFileHistory) {
+            if (!( (commandMap.has(label)))) {
+                dedupedShellFileItems.unshift({
+                    label: formatLabel(label),
+                    rawLabel: label
+                });
+            }
+        }
+        if (dedupedShellFileItems.length > 0) {
+            items.push({ type: 'separator', label: ( localize(11153, '{0} history', instance.shellType)) }, ...dedupedShellFileItems);
+        }
+    }
+    else {
+        placeholder = isMacintosh
+            ? ( localize(11154, 'Select a directory to go to (hold Option-key to edit the command)'))
+            : ( localize(11155, 'Select a directory to go to (hold Alt-key to edit the command)'));
+        const cwds = instance.capabilities.get(0 )?.cwds || [];
+        if (cwds && cwds.length > 0) {
+            for (const label of cwds) {
+                items.push({ label, rawLabel: label });
+            }
+            items = items.reverse();
+            items.unshift({ type: 'separator', label: terminalStrings.currentSessionCategory });
+        }
+        const history = instantiationService.invokeFunction(getDirectoryHistory);
+        const previousSessionItems = [];
+        for (const [label, info] of history.entries) {
+            if ((info === null || info.remoteAuthority === instance.remoteAuthority) && !cwds.includes(label)) {
+                previousSessionItems.unshift({
+                    label,
+                    rawLabel: label,
+                    buttons: [removeFromCommandHistoryButton]
+                });
+            }
+        }
+        if (previousSessionItems.length > 0) {
+            items.push({ type: 'separator', label: terminalStrings.previousSessionCategory }, ...previousSessionItems);
+        }
+    }
+    if (items.length === 0) {
+        return;
+    }
+    const disposables = ( (new DisposableStore()));
+    const fuzzySearchToggle = disposables.add(( (new Toggle({
+        title: 'Fuzzy search',
+        icon: commandHistoryFuzzySearchIcon,
+        isChecked: filterMode === 'fuzzy',
+        inputActiveOptionBorder: asCssVariable(inputActiveOptionBorder),
+        inputActiveOptionForeground: asCssVariable(inputActiveOptionForeground),
+        inputActiveOptionBackground: asCssVariable(inputActiveOptionBackground)
+    }))));
+    disposables.add(fuzzySearchToggle.onChange(() => {
+        instantiationService.invokeFunction(showRunRecentQuickPick, instance, terminalInRunCommandPicker, type, fuzzySearchToggle.checked ? 'fuzzy' : 'contiguous', quickPick.value);
+    }));
+    const outputProvider = disposables.add(instantiationService.createInstance(TerminalOutputProvider));
+    const quickPick = disposables.add(quickInputService.createQuickPick({ useSeparators: true }));
+    const originalItems = items;
+    quickPick.items = [...originalItems];
+    quickPick.sortByLabel = false;
+    quickPick.placeholder = placeholder;
+    quickPick.matchOnLabelMode = filterMode || 'contiguous';
+    quickPick.toggles = [fuzzySearchToggle];
+    disposables.add(quickPick.onDidTriggerItemButton(async (e) => {
+        if (e.button === removeFromCommandHistoryButton) {
+            if (type === 'command') {
+                instantiationService.invokeFunction(getCommandHistory)?.remove(e.item.label);
+            }
+            else {
+                instantiationService.invokeFunction(getDirectoryHistory)?.remove(e.item.label);
+            }
+        }
+        else if (e.button === commandOutputButton) {
+            const selectedCommand = e.item.command;
+            const output = selectedCommand?.getOutput();
+            if (output && selectedCommand?.command) {
+                const textContent = await outputProvider.provideTextContent(( (URI.from({
+                    scheme: TerminalOutputProvider.scheme,
+                    path: `${selectedCommand.command}... ${fromNow(selectedCommand.timestamp, true)}`,
+                    fragment: output,
+                    query: `terminal-output-${selectedCommand.timestamp}-${instance.instanceId}`
+                }))));
+                if (textContent) {
+                    await editorService.openEditor({
+                        resource: textContent.uri
+                    });
+                }
+            }
+        }
+        await instantiationService.invokeFunction(showRunRecentQuickPick, instance, terminalInRunCommandPicker, type, filterMode, value);
+    }));
+    disposables.add(quickPick.onDidChangeValue(async (value) => {
+        if (!value) {
+            await instantiationService.invokeFunction(showRunRecentQuickPick, instance, terminalInRunCommandPicker, type, filterMode, value);
+        }
+    }));
+    let terminalScrollStateSaved = false;
+    function restoreScrollState() {
+        terminalScrollStateSaved = false;
+        instance.xterm?.markTracker.restoreScrollState();
+        instance.xterm?.markTracker.clear();
+    }
+    disposables.add(quickPick.onDidChangeActive(async () => {
+        const xterm = instance.xterm;
+        if (!xterm) {
+            return;
+        }
+        const [item] = quickPick.activeItems;
+        if (!item) {
+            return;
+        }
+        if ('command' in item && item.command && item.command.marker) {
+            if (!terminalScrollStateSaved) {
+                xterm.markTracker.saveScrollState();
+                terminalScrollStateSaved = true;
+            }
+            const promptRowCount = item.command.getPromptRowCount();
+            const commandRowCount = item.command.getCommandRowCount();
+            xterm.markTracker.revealRange({
+                start: {
+                    x: 1,
+                    y: item.command.marker.line - (promptRowCount - 1) + 1
+                },
+                end: {
+                    x: instance.cols,
+                    y: item.command.marker.line + (commandRowCount - 1) + 1
+                }
+            });
+        }
+        else {
+            restoreScrollState();
+        }
+    }));
+    disposables.add(quickPick.onDidAccept(async () => {
+        const result = quickPick.activeItems[0];
+        let text;
+        if (type === 'cwd') {
+            text = `cd ${await instance.preparePathForShell(result.rawLabel)}`;
+        }
+        else {
+            text = result.rawLabel;
+        }
+        quickPick.hide();
+        instance.runCommand(text, !quickPick.keyMods.alt);
+        if (quickPick.keyMods.alt) {
+            instance.focus();
+        }
+        restoreScrollState();
+    }));
+    disposables.add(quickPick.onDidHide(() => restoreScrollState()));
+    if (value) {
+        quickPick.value = value;
+    }
+    return (
+         (new Promise(r => {
+            terminalInRunCommandPicker.set(true);
+            disposables.add(showWithPinnedItems(storageService, runRecentStorageKey, quickPick));
+            disposables.add(quickPick.onDidHide(() => {
+                terminalInRunCommandPicker.set(false);
+                accessibleViewService.showLastProvider("terminal" );
+                r();
+                disposables.dispose();
+            }));
+        }))
+    );
+}
+let TerminalOutputProvider = class TerminalOutputProvider extends Disposable {
+    static { TerminalOutputProvider_1 = this; }
+    static { this.scheme = 'TERMINAL_OUTPUT'; }
+    constructor(textModelResolverService, _modelService) {
+        super();
+        this._modelService = _modelService;
+        this._register(textModelResolverService.registerTextModelContentProvider(TerminalOutputProvider_1.scheme, this));
+    }
+    async provideTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing && !existing.isDisposed()) {
+            return existing;
+        }
+        return this._modelService.createModel(resource.fragment, null, resource, false);
+    }
+};
+TerminalOutputProvider = TerminalOutputProvider_1 = ( (__decorate([
+    ( (__param(0, ITextModelService))),
+    ( (__param(1, IModelService)))
+], TerminalOutputProvider)));
+export { showRunRecentQuickPick };

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

@@ -0,0 +1,121 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import { listWarningForeground, listErrorForeground } from '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { spinningLoading } from '../../../../platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { mainWindow } from '../../../../base/browser/window.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) {
+                if (s.icon || !result?.icon) {
+                    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) {
+            mainWindow.clearTimeout(outTimeout);
+            this._statusTimeouts.delete(status.id);
+        }
+        if (duration && duration > 0) {
+            const timeout = mainWindow.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$1.Error:
+            return listErrorForeground;
+        case Severity$1.Warning:
+            return listWarningForeground;
+        default:
+            return '';
+    }
+}
+export { TerminalStatusList, getColorForSeverity };