@codingame/monaco-vscode-api 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/tasks/browser/taskQuickPick.js

@@ -1,450 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { deepClone } from '../../../../base/common/objects.js';
-import { ConfiguringTask, ContributedTask, CustomTask } from '../common/tasks.js';
-import { isString } from '../../../../base/common/types.js';
-import { ITaskService } from '../common/taskService.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { Event } from '../../../../base/common/event.js';
-import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { IThemeService } from '../../../../platform/theme/common/themeService.js';
-import { ThemeIcon } from '../../../../base/common/themables.js';
-import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { createColorStyleElement, getColorClass } from '../../terminal/browser/terminalIcon.js';
-import { showWithPinnedItems } from '../../../../platform/quickinput/browser/quickPickPin.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-var TaskQuickPick_1;
-const QUICKOPEN_DETAIL_CONFIG = 'task.quickOpen.detail';
-const QUICKOPEN_SKIP_CONFIG = 'task.quickOpen.skip';
-function isWorkspaceFolder(folder) {
-    return 'uri' in folder;
-}
-const SHOW_ALL = ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskQuickPick',
-    'taskQuickPick.showAll',
-    "Show All Tasks..."
-));
-const configureTaskIcon = registerIcon('tasks-list-configure', Codicon.gear, ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskQuickPick',
-    'configureTaskIcon',
-    'Configuration icon in the tasks selection list.'
-)));
-const removeTaskIcon = registerIcon('tasks-remove', Codicon.close, ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskQuickPick',
-    'removeTaskIcon',
-    'Icon for remove in the tasks selection list.'
-)));
-const runTaskStorageKey = 'runTaskStorageKey';
-let TaskQuickPick = TaskQuickPick_1 = class TaskQuickPick extends Disposable {
-    constructor(_taskService, _configurationService, _quickInputService, _notificationService, _themeService, _dialogService, _storageService) {
-        super();
-        this._taskService = _taskService;
-        this._configurationService = _configurationService;
-        this._quickInputService = _quickInputService;
-        this._notificationService = _notificationService;
-        this._themeService = _themeService;
-        this._dialogService = _dialogService;
-        this._storageService = _storageService;
-        this._sorter = this._taskService.createSorter();
-    }
-    _showDetail() {
-        return !!this._configurationService.getValue(QUICKOPEN_DETAIL_CONFIG);
-    }
-    _guessTaskLabel(task) {
-        if (task._label) {
-            return task._label;
-        }
-        if (ConfiguringTask.is(task)) {
-            let label = task.configures.type;
-            const configures = deepClone(task.configures);
-            delete configures['_key'];
-            delete configures['type'];
-            ( Object.keys(configures)).forEach(key => label += `: ${configures[key]}`);
-            return label;
-        }
-        return '';
-    }
-    static getTaskLabelWithIcon(task, labelGuess) {
-        const label = labelGuess || task._label;
-        const icon = task.configurationProperties.icon;
-        if (!icon) {
-            return `${label}`;
-        }
-        return icon.id ? `$(${icon.id}) ${label}` : `$(${Codicon.tools.id}) ${label}`;
-    }
-    static applyColorStyles(task, entry, themeService) {
-        if (task.configurationProperties.icon?.color) {
-            const colorTheme = themeService.getColorTheme();
-            createColorStyleElement(colorTheme);
-            entry.iconClasses = [getColorClass(task.configurationProperties.icon.color)];
-        }
-    }
-    _createTaskEntry(task, extraButtons = []) {
-        const buttons = [
-            { iconClass: ThemeIcon.asClassName(configureTaskIcon), tooltip: ( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'configureTask',
-                "Configure Task"
-            )) },
-            ...extraButtons
-        ];
-        const entry = { label: TaskQuickPick_1.getTaskLabelWithIcon(task, this._guessTaskLabel(task)), description: this._taskService.getTaskDescription(task), task, detail: this._showDetail() ? task.configurationProperties.detail : undefined, buttons };
-        TaskQuickPick_1.applyColorStyles(task, entry, this._themeService);
-        return entry;
-    }
-    _createEntriesForGroup(entries, tasks, groupLabel, extraButtons = []) {
-        entries.push({ type: 'separator', label: groupLabel });
-        tasks.forEach(task => {
-            if (!task.configurationProperties.hide) {
-                entries.push(this._createTaskEntry(task, extraButtons));
-            }
-        });
-    }
-    _createTypeEntries(entries, types) {
-        entries.push({ type: 'separator', label: ( localizeWithPath(
-            'vs/workbench/contrib/tasks/browser/taskQuickPick',
-            'contributedTasks',
-            "contributed"
-        )) });
-        types.forEach(type => {
-            entries.push({ label: `$(folder) ${type}`, task: type, ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'taskType',
-                "All {0} tasks",
-                type
-            )) });
-        });
-        entries.push({ label: SHOW_ALL, task: SHOW_ALL, alwaysShow: true });
-    }
-    _handleFolderTaskResult(result) {
-        const tasks = [];
-        Array.from(result).forEach(([key, folderTasks]) => {
-            if (folderTasks.set) {
-                tasks.push(...folderTasks.set.tasks);
-            }
-            if (folderTasks.configurations) {
-                for (const configuration in folderTasks.configurations.byIdentifier) {
-                    tasks.push(folderTasks.configurations.byIdentifier[configuration]);
-                }
-            }
-        });
-        return tasks;
-    }
-    _dedupeConfiguredAndRecent(recentTasks, configuredTasks) {
-        let dedupedConfiguredTasks = [];
-        const foundRecentTasks = Array(recentTasks.length).fill(false);
-        for (let j = 0; j < configuredTasks.length; j++) {
-            const workspaceFolder = configuredTasks[j].getWorkspaceFolder()?.uri.toString();
-            const definition = configuredTasks[j].getDefinition()?._key;
-            const type = configuredTasks[j].type;
-            const label = configuredTasks[j]._label;
-            const recentKey = configuredTasks[j].getKey();
-            const findIndex = recentTasks.findIndex((value) => {
-                return (workspaceFolder && definition && value.getWorkspaceFolder()?.uri.toString() === workspaceFolder
-                    && ((value.getDefinition()?._key === definition) || (value.type === type && value._label === label)))
-                    || (recentKey && value.getKey() === recentKey);
-            });
-            if (findIndex === -1) {
-                dedupedConfiguredTasks.push(configuredTasks[j]);
-            }
-            else {
-                recentTasks[findIndex] = configuredTasks[j];
-                foundRecentTasks[findIndex] = true;
-            }
-        }
-        dedupedConfiguredTasks = dedupedConfiguredTasks.sort((a, b) => this._sorter.compare(a, b));
-        const prunedRecentTasks = [];
-        for (let i = 0; i < recentTasks.length; i++) {
-            if (foundRecentTasks[i] || ConfiguringTask.is(recentTasks[i])) {
-                prunedRecentTasks.push(recentTasks[i]);
-            }
-        }
-        return { configuredTasks: dedupedConfiguredTasks, recentTasks: prunedRecentTasks };
-    }
-    async getTopLevelEntries(defaultEntry) {
-        if (this._topLevelEntries !== undefined) {
-            return { entries: this._topLevelEntries };
-        }
-        let recentTasks = (await this._taskService.getSavedTasks('historical')).reverse();
-        const configuredTasks = this._handleFolderTaskResult(await this._taskService.getWorkspaceTasks());
-        const extensionTaskTypes = this._taskService.taskTypes();
-        this._topLevelEntries = [];
-        const dedupeAndPrune = this._dedupeConfiguredAndRecent(recentTasks, configuredTasks);
-        const dedupedConfiguredTasks = dedupeAndPrune.configuredTasks;
-        recentTasks = dedupeAndPrune.recentTasks;
-        if (recentTasks.length > 0) {
-            const removeRecentButton = {
-                iconClass: ThemeIcon.asClassName(removeTaskIcon),
-                tooltip: ( localizeWithPath(
-                    'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                    'removeRecent',
-                    'Remove Recently Used Task'
-                ))
-            };
-            this._createEntriesForGroup(this._topLevelEntries, recentTasks, ( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'recentlyUsed',
-                'recently used'
-            )), [removeRecentButton]);
-        }
-        if (configuredTasks.length > 0) {
-            if (dedupedConfiguredTasks.length > 0) {
-                this._createEntriesForGroup(this._topLevelEntries, dedupedConfiguredTasks, ( localizeWithPath(
-                    'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                    'configured',
-                    'configured'
-                )));
-            }
-        }
-        if (defaultEntry && (configuredTasks.length === 0)) {
-            this._topLevelEntries.push({ type: 'separator', label: ( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'configured',
-                'configured'
-            )) });
-            this._topLevelEntries.push(defaultEntry);
-        }
-        if (extensionTaskTypes.length > 0) {
-            this._createTypeEntries(this._topLevelEntries, extensionTaskTypes);
-        }
-        return { entries: this._topLevelEntries, isSingleConfigured: configuredTasks.length === 1 ? configuredTasks[0] : undefined };
-    }
-    async handleSettingOption(selectedType) {
-        const { confirmed } = await this._dialogService.confirm({
-            type: Severity.Warning,
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'TaskQuickPick.changeSettingDetails',
-                "Task detection for {0} tasks causes files in any workspace you open to be run as code. Enabling {0} task detection is a user setting and will apply to any workspace you open. \n\n Do you want to enable {0} task detection for all workspaces?",
-                selectedType
-            )),
-            cancelButton: ( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'TaskQuickPick.changeSettingNo',
-                "No"
-            ))
-        });
-        if (confirmed) {
-            await this._configurationService.updateValue(`${selectedType}.autoDetect`, 'on');
-            await ( new Promise(resolve => setTimeout(() => resolve(), 100)));
-            return this.show(( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'TaskService.pickRunTask',
-                'Select the task to run'
-            )), undefined, selectedType);
-        }
-        return undefined;
-    }
-    async show(placeHolder, defaultEntry, startAtType, name) {
-        const picker = this._quickInputService.createQuickPick();
-        picker.placeholder = placeHolder;
-        picker.matchOnDescription = true;
-        picker.ignoreFocusOut = false;
-        picker.onDidTriggerItemButton(async (context) => {
-            const task = context.item.task;
-            if (context.button.iconClass === ThemeIcon.asClassName(removeTaskIcon)) {
-                const key = (task && !isString(task)) ? task.getKey() : undefined;
-                if (key) {
-                    this._taskService.removeRecentlyUsedTask(key);
-                }
-                const indexToRemove = picker.items.indexOf(context.item);
-                if (indexToRemove >= 0) {
-                    picker.items = [...picker.items.slice(0, indexToRemove), ...picker.items.slice(indexToRemove + 1)];
-                }
-            }
-            else if (context.button.iconClass === ThemeIcon.asClassName(configureTaskIcon)) {
-                this._quickInputService.cancel();
-                if (ContributedTask.is(task)) {
-                    this._taskService.customize(task, undefined, true);
-                }
-                else if (CustomTask.is(task) || ConfiguringTask.is(task)) {
-                    let canOpenConfig = false;
-                    try {
-                        canOpenConfig = await this._taskService.openConfig(task);
-                    }
-                    catch (e) {
-                    }
-                    if (!canOpenConfig) {
-                        this._taskService.customize(task, undefined, true);
-                    }
-                }
-            }
-        });
-        if (name) {
-            picker.value = name;
-        }
-        let firstLevelTask = startAtType;
-        if (!firstLevelTask) {
-            const topLevelEntriesResult = await this.getTopLevelEntries(defaultEntry);
-            if (topLevelEntriesResult.isSingleConfigured && this._configurationService.getValue(QUICKOPEN_SKIP_CONFIG)) {
-                picker.dispose();
-                return this._toTask(topLevelEntriesResult.isSingleConfigured);
-            }
-            const taskQuickPickEntries = topLevelEntriesResult.entries;
-            firstLevelTask = await this._doPickerFirstLevel(picker, taskQuickPickEntries);
-        }
-        do {
-            if (isString(firstLevelTask)) {
-                if (name) {
-                    await this._doPickerFirstLevel(picker, (await this.getTopLevelEntries(defaultEntry)).entries);
-                    picker.dispose();
-                    return undefined;
-                }
-                const selectedEntry = await this.doPickerSecondLevel(picker, firstLevelTask);
-                if (selectedEntry && !selectedEntry.settingType && selectedEntry.task === null) {
-                    picker.value = '';
-                    firstLevelTask = await this._doPickerFirstLevel(picker, (await this.getTopLevelEntries(defaultEntry)).entries);
-                }
-                else if (selectedEntry && isString(selectedEntry.settingType)) {
-                    picker.dispose();
-                    return this.handleSettingOption(selectedEntry.settingType);
-                }
-                else {
-                    picker.dispose();
-                    return (selectedEntry?.task && !isString(selectedEntry?.task)) ? this._toTask(selectedEntry?.task) : undefined;
-                }
-            }
-            else if (firstLevelTask) {
-                picker.dispose();
-                return this._toTask(firstLevelTask);
-            }
-            else {
-                picker.dispose();
-                return firstLevelTask;
-            }
-        } while (1);
-        return;
-    }
-    async _doPickerFirstLevel(picker, taskQuickPickEntries) {
-        picker.items = taskQuickPickEntries;
-        showWithPinnedItems(this._storageService, runTaskStorageKey, picker, true);
-        const firstLevelPickerResult = await ( new Promise(resolve => {
-            Event.once(picker.onDidAccept)(async () => {
-                resolve(picker.selectedItems ? picker.selectedItems[0] : undefined);
-            });
-        }));
-        return firstLevelPickerResult?.task;
-    }
-    async doPickerSecondLevel(picker, type, name) {
-        picker.busy = true;
-        if (type === SHOW_ALL) {
-            const items = ( (await this._taskService.tasks()).filter(t => !t.configurationProperties.hide).sort((a, b) => this._sorter.compare(a, b)).map(task => this._createTaskEntry(task)));
-            items.push(...TaskQuickPick_1.allSettingEntries(this._configurationService));
-            picker.items = items;
-        }
-        else {
-            picker.value = name || '';
-            picker.items = await this._getEntriesForProvider(type);
-        }
-        await picker.show();
-        picker.busy = false;
-        const secondLevelPickerResult = await ( new Promise(resolve => {
-            Event.once(picker.onDidAccept)(async () => {
-                resolve(picker.selectedItems ? picker.selectedItems[0] : undefined);
-            });
-        }));
-        return secondLevelPickerResult;
-    }
-    static allSettingEntries(configurationService) {
-        const entries = [];
-        const gruntEntry = TaskQuickPick_1.getSettingEntry(configurationService, 'grunt');
-        if (gruntEntry) {
-            entries.push(gruntEntry);
-        }
-        const gulpEntry = TaskQuickPick_1.getSettingEntry(configurationService, 'gulp');
-        if (gulpEntry) {
-            entries.push(gulpEntry);
-        }
-        const jakeEntry = TaskQuickPick_1.getSettingEntry(configurationService, 'jake');
-        if (jakeEntry) {
-            entries.push(jakeEntry);
-        }
-        return entries;
-    }
-    static getSettingEntry(configurationService, type) {
-        if (configurationService.getValue(`${type}.autoDetect`) === 'off') {
-            return {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                    'TaskQuickPick.changeSettingsOptions',
-                    "$(gear) {0} task detection is turned off. Enable {1} task detection...",
-                    type[0].toUpperCase() + type.slice(1),
-                    type
-                )),
-                task: null,
-                settingType: type,
-                alwaysShow: true
-            };
-        }
-        return undefined;
-    }
-    async _getEntriesForProvider(type) {
-        const tasks = (await this._taskService.tasks({ type })).sort((a, b) => this._sorter.compare(a, b));
-        let taskQuickPickEntries = [];
-        if (tasks.length > 0) {
-            for (const task of tasks) {
-                if (!task.configurationProperties.hide) {
-                    taskQuickPickEntries.push(this._createTaskEntry(task));
-                }
-            }
-            taskQuickPickEntries.push({
-                type: 'separator'
-            }, {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                    'TaskQuickPick.goBack',
-                    'Go back ↩'
-                )),
-                task: null,
-                alwaysShow: true
-            });
-        }
-        else {
-            taskQuickPickEntries = [{
-                    label: ( localizeWithPath(
-                        'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                        'TaskQuickPick.noTasksForType',
-                        'No {0} tasks found. Go back ↩',
-                        type
-                    )),
-                    task: null,
-                    alwaysShow: true
-                }];
-        }
-        const settingEntry = TaskQuickPick_1.getSettingEntry(this._configurationService, type);
-        if (settingEntry) {
-            taskQuickPickEntries.push(settingEntry);
-        }
-        return taskQuickPickEntries;
-    }
-    async _toTask(task) {
-        if (!ConfiguringTask.is(task)) {
-            return task;
-        }
-        const resolvedTask = await this._taskService.tryResolveTask(task);
-        if (!resolvedTask) {
-            this._notificationService.error(( localizeWithPath(
-                'vs/workbench/contrib/tasks/browser/taskQuickPick',
-                'noProviderForTask',
-                "There is no task provider registered for tasks of type \"{0}\".",
-                task.type
-            )));
-        }
-        return resolvedTask;
-    }
-};
-TaskQuickPick = TaskQuickPick_1 = ( __decorate([
-    ( __param(0, ITaskService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, IStorageService))
-], TaskQuickPick));
-export { QUICKOPEN_DETAIL_CONFIG, QUICKOPEN_SKIP_CONFIG, TaskQuickPick, configureTaskIcon, isWorkspaceFolder };

package/vscode/src/vs/workbench/contrib/tasks/browser/taskService.js

@@ -1,36 +0,0 @@
-import { localizeWithPath } from '../../../../nls.js';
-import { ExecutionEngine } from '../common/tasks.js';
-import { AbstractTaskService } from './abstractTaskService.js';
-import '../../../../platform/instantiation/common/instantiation.js';
-import '../../../../platform/contextkey/common/contextkey.js';
-class TaskService extends AbstractTaskService {
-    static { this.ProcessTaskSystemSupportMessage = ( localizeWithPath(
-        'vs/workbench/contrib/tasks/browser/taskService',
-        'taskService.processTaskSystem',
-        'Process task system is not support in the web.'
-    )); }
-    _getTaskSystem() {
-        if (this._taskSystem) {
-            return this._taskSystem;
-        }
-        if (this.executionEngine !== ExecutionEngine.Terminal) {
-            throw new Error(TaskService.ProcessTaskSystemSupportMessage);
-        }
-        this._taskSystem = this._createTerminalTaskSystem();
-        this._taskSystemListeners =
-            [
-                this._taskSystem.onDidStateChange((event) => {
-                    this._taskRunningState.set(this._taskSystem.isActiveSync());
-                    this._onDidStateChange.fire(event);
-                }),
-            ];
-        return this._taskSystem;
-    }
-    _computeLegacyConfiguration(workspaceFolder) {
-        throw new Error(TaskService.ProcessTaskSystemSupportMessage);
-    }
-    _versionAndEngineCompatible(filter) {
-        return this.executionEngine === ExecutionEngine.Terminal;
-    }
-}
-export { TaskService };

package/vscode/src/vs/workbench/contrib/tasks/browser/taskTerminalStatus.js

@@ -1,189 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { Disposable, toDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
-import Severity$1 from '../../../../base/common/severity.js';
-import { StartStopProblemCollector } from '../common/problemCollectors.js';
-import { ITaskService } from '../common/taskService.js';
-import { MarkerSeverity } from '../../../../platform/markers/common/markers.js';
-import { spinningLoading } from '../../../../platform/theme/common/iconRegistry.js';
-import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
-const TASK_TERMINAL_STATUS_ID = 'task_terminal_status';
-const ACTIVE_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: spinningLoading, severity: Severity$1.Info, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.active',
-    "Task is running"
-)) };
-const SUCCEEDED_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.check, severity: Severity$1.Info, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.succeeded',
-    "Task succeeded"
-)) };
-const SUCCEEDED_INACTIVE_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.check, severity: Severity$1.Info, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.succeededInactive',
-    "Task succeeded and waiting..."
-)) };
-const FAILED_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.error, severity: Severity$1.Error, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.errors',
-    "Task has errors"
-)) };
-const FAILED_INACTIVE_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.error, severity: Severity$1.Error, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.errorsInactive',
-    "Task has errors and is waiting..."
-)) };
-const WARNING_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.warning, severity: Severity$1.Warning, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.warnings',
-    "Task has warnings"
-)) };
-const WARNING_INACTIVE_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.warning, severity: Severity$1.Warning, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.warningsInactive',
-    "Task has warnings and is waiting..."
-)) };
-const INFO_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.info, severity: Severity$1.Info, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.infos',
-    "Task has infos"
-)) };
-const INFO_INACTIVE_TASK_STATUS = { id: TASK_TERMINAL_STATUS_ID, icon: Codicon.info, severity: Severity$1.Info, tooltip: ( localizeWithPath(
-    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-    'taskTerminalStatus.infosInactive',
-    "Task has infos and is waiting..."
-)) };
-let TaskTerminalStatus = class TaskTerminalStatus extends Disposable {
-    constructor(taskService, _accessibilitySignalService) {
-        super();
-        this._accessibilitySignalService = _accessibilitySignalService;
-        this.terminalMap = ( new Map());
-        this._register(taskService.onDidStateChange((event) => {
-            switch (event.kind) {
-                case "processStarted" :
-                case "active" :
-                    this.eventActive(event);
-                    break;
-                case "inactive" :
-                    this.eventInactive(event);
-                    break;
-                case "processEnded" :
-                    this.eventEnd(event);
-                    break;
-            }
-        }));
-        this._register(toDisposable(() => {
-            for (const terminalData of ( this.terminalMap.values())) {
-                terminalData.disposeListener?.dispose();
-            }
-            this.terminalMap.clear();
-        }));
-    }
-    addTerminal(task, terminal, problemMatcher) {
-        const status = { id: TASK_TERMINAL_STATUS_ID, severity: Severity$1.Info };
-        terminal.statusList.add(status);
-        this._register(problemMatcher.onDidFindFirstMatch(() => {
-            this._marker = terminal.registerMarker();
-            if (this._marker) {
-                this._register(this._marker);
-            }
-        }));
-        this._register(problemMatcher.onDidFindErrors(() => {
-            if (this._marker) {
-                terminal.addBufferMarker({ marker: this._marker, hoverMessage: ( localizeWithPath(
-                    'vs/workbench/contrib/tasks/browser/taskTerminalStatus',
-                    'task.watchFirstError',
-                    "Beginning of detected errors for this run"
-                )), disableCommandStorage: true });
-            }
-        }));
-        this._register(problemMatcher.onDidRequestInvalidateLastMarker(() => {
-            this._marker?.dispose();
-            this._marker = undefined;
-        }));
-        this.terminalMap.set(terminal.instanceId, { terminal, task, status, problemMatcher, taskRunEnded: false });
-    }
-    terminalFromEvent(event) {
-        if (!('terminalId' in event) || !event.terminalId) {
-            return undefined;
-        }
-        return this.terminalMap.get(event.terminalId);
-    }
-    eventEnd(event) {
-        const terminalData = this.terminalFromEvent(event);
-        if (!terminalData) {
-            return;
-        }
-        terminalData.taskRunEnded = true;
-        terminalData.terminal.statusList.remove(terminalData.status);
-        if ((event.exitCode === 0) && (terminalData.problemMatcher.numberOfMatches === 0)) {
-            this._accessibilitySignalService.playSignal(AccessibilitySignal.taskCompleted);
-            if (terminalData.task.configurationProperties.isBackground) {
-                for (const status of terminalData.terminal.statusList.statuses) {
-                    terminalData.terminal.statusList.remove(status);
-                }
-            }
-            else {
-                terminalData.terminal.statusList.add(SUCCEEDED_TASK_STATUS);
-            }
-        }
-        else if (event.exitCode || terminalData.problemMatcher.maxMarkerSeverity === MarkerSeverity.Error) {
-            this._accessibilitySignalService.playSignal(AccessibilitySignal.taskFailed);
-            terminalData.terminal.statusList.add(FAILED_TASK_STATUS);
-        }
-        else if (terminalData.problemMatcher.maxMarkerSeverity === MarkerSeverity.Warning) {
-            terminalData.terminal.statusList.add(WARNING_TASK_STATUS);
-        }
-        else if (terminalData.problemMatcher.maxMarkerSeverity === MarkerSeverity.Info) {
-            terminalData.terminal.statusList.add(INFO_TASK_STATUS);
-        }
-    }
-    eventInactive(event) {
-        const terminalData = this.terminalFromEvent(event);
-        if (!terminalData || !terminalData.problemMatcher || terminalData.taskRunEnded) {
-            return;
-        }
-        terminalData.terminal.statusList.remove(terminalData.status);
-        if (terminalData.problemMatcher.numberOfMatches === 0) {
-            this._accessibilitySignalService.playSignal(AccessibilitySignal.taskCompleted);
-            terminalData.terminal.statusList.add(SUCCEEDED_INACTIVE_TASK_STATUS);
-        }
-        else if (terminalData.problemMatcher.maxMarkerSeverity === MarkerSeverity.Error) {
-            this._accessibilitySignalService.playSignal(AccessibilitySignal.taskFailed);
-            terminalData.terminal.statusList.add(FAILED_INACTIVE_TASK_STATUS);
-        }
-        else if (terminalData.problemMatcher.maxMarkerSeverity === MarkerSeverity.Warning) {
-            terminalData.terminal.statusList.add(WARNING_INACTIVE_TASK_STATUS);
-        }
-        else if (terminalData.problemMatcher.maxMarkerSeverity === MarkerSeverity.Info) {
-            terminalData.terminal.statusList.add(INFO_INACTIVE_TASK_STATUS);
-        }
-    }
-    eventActive(event) {
-        const terminalData = this.terminalFromEvent(event);
-        if (!terminalData) {
-            return;
-        }
-        if (!terminalData.disposeListener) {
-            terminalData.disposeListener = this._register(( new MutableDisposable()));
-            terminalData.disposeListener.value = terminalData.terminal.onDisposed(() => {
-                if (!event.terminalId) {
-                    return;
-                }
-                this.terminalMap.delete(event.terminalId);
-                terminalData.disposeListener?.dispose();
-            });
-        }
-        terminalData.taskRunEnded = false;
-        terminalData.terminal.statusList.remove(terminalData.status);
-        if ((terminalData.problemMatcher instanceof StartStopProblemCollector) || (terminalData.problemMatcher?.problemMatchers.length > 0) || event.runType === "singleRun" ) {
-            terminalData.terminal.statusList.add(ACTIVE_TASK_STATUS);
-        }
-    }
-};
-TaskTerminalStatus = ( __decorate([
-    ( __param(0, ITaskService)),
-    ( __param(1, IAccessibilitySignalService))
-], TaskTerminalStatus));
-export { ACTIVE_TASK_STATUS, FAILED_TASK_STATUS, SUCCEEDED_TASK_STATUS, TaskTerminalStatus };