@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,450 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,189 @@
+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 };