@codingame/monaco-vscode-api 1.79.0 → 1.79.1

package/dist/vscode/vs/workbench/contrib/search/common/cacheState.js

@@ -0,0 +1,85 @@
+import { defaultGenerator } from 'monaco-editor/esm/vs/base/common/idGenerator.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+var LoadingPhase;
+( (function(LoadingPhase) {
+    LoadingPhase[LoadingPhase["Created"] = 1] = "Created";
+    LoadingPhase[LoadingPhase["Loading"] = 2] = "Loading";
+    LoadingPhase[LoadingPhase["Loaded"] = 3] = "Loaded";
+    LoadingPhase[LoadingPhase["Errored"] = 4] = "Errored";
+    LoadingPhase[LoadingPhase["Disposed"] = 5] = "Disposed";
+})(LoadingPhase || (LoadingPhase = {})));
+class FileQueryCacheState {
+    get cacheKey() {
+        if (this.loadingPhase === LoadingPhase.Loaded || !this.previousCacheState) {
+            return this._cacheKey;
+        }
+        return this.previousCacheState.cacheKey;
+    }
+    get isLoaded() {
+        const isLoaded = this.loadingPhase === LoadingPhase.Loaded;
+        return isLoaded || !this.previousCacheState ? isLoaded : this.previousCacheState.isLoaded;
+    }
+    get isUpdating() {
+        const isUpdating = this.loadingPhase === LoadingPhase.Loading;
+        return isUpdating || !this.previousCacheState ? isUpdating : this.previousCacheState.isUpdating;
+    }
+    constructor(cacheQuery, loadFn, disposeFn, previousCacheState) {
+        this.cacheQuery = cacheQuery;
+        this.loadFn = loadFn;
+        this.disposeFn = disposeFn;
+        this.previousCacheState = previousCacheState;
+        this._cacheKey = defaultGenerator.nextId();
+        this.query = this.cacheQuery(this._cacheKey);
+        this.loadingPhase = LoadingPhase.Created;
+        if (this.previousCacheState) {
+            const current = Object.assign({}, this.query, { cacheKey: null });
+            const previous = Object.assign({}, this.previousCacheState.query, { cacheKey: null });
+            if (!equals(current, previous)) {
+                this.previousCacheState.dispose();
+                this.previousCacheState = undefined;
+            }
+        }
+    }
+    load() {
+        if (this.isUpdating) {
+            return this;
+        }
+        this.loadingPhase = LoadingPhase.Loading;
+        this.loadPromise = (async () => {
+            try {
+                await this.loadFn(this.query);
+                this.loadingPhase = LoadingPhase.Loaded;
+                if (this.previousCacheState) {
+                    this.previousCacheState.dispose();
+                    this.previousCacheState = undefined;
+                }
+            }
+            catch (error) {
+                this.loadingPhase = LoadingPhase.Errored;
+                throw error;
+            }
+        })();
+        return this;
+    }
+    dispose() {
+        if (this.loadPromise) {
+            (async () => {
+                try {
+                    await this.loadPromise;
+                }
+                catch (error) {
+                }
+                this.loadingPhase = LoadingPhase.Disposed;
+                this.disposeFn(this._cacheKey);
+            })();
+        }
+        else {
+            this.loadingPhase = LoadingPhase.Disposed;
+        }
+        if (this.previousCacheState) {
+            this.previousCacheState.dispose();
+            this.previousCacheState = undefined;
+        }
+    }
+}
+export { FileQueryCacheState };

package/dist/vscode/vs/workbench/contrib/search/common/constants.js

@@ -0,0 +1,2 @@
+const ShowAllSymbolsActionId = 'workbench.action.showAllSymbols';
+export { ShowAllSymbolsActionId };

package/dist/vscode/vs/workbench/contrib/search/common/search.js

@@ -1,3 +1,13 @@
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { groupBy } from 'monaco-editor/esm/vs/base/common/arrays.js';
 var WorkspaceSymbolProviderRegistry;
 ( (function(WorkspaceSymbolProviderRegistry) {
     const _supports = [];
@@ -24,4 +34,112 @@ var WorkspaceSymbolProviderRegistry;
     }
     WorkspaceSymbolProviderRegistry.all = all;
 })(WorkspaceSymbolProviderRegistry || (WorkspaceSymbolProviderRegistry = {})));
-export { WorkspaceSymbolProviderRegistry };
+class WorkspaceSymbolItem {
+    constructor(symbol, provider) {
+        this.symbol = symbol;
+        this.provider = provider;
+    }
+}
+async function getWorkspaceSymbols(query, token = CancellationToken.None) {
+    const all = [];
+    const promises = ( WorkspaceSymbolProviderRegistry.all().map(async (provider) => {
+        try {
+            const value = await provider.provideWorkspaceSymbols(query, token);
+            if (!value) {
+                return;
+            }
+            for (const symbol of value) {
+                all.push(( new WorkspaceSymbolItem(symbol, provider)));
+            }
+        }
+        catch (err) {
+            onUnexpectedExternalError(err);
+        }
+    }));
+    await Promise.all(promises);
+    if (token.isCancellationRequested) {
+        return [];
+    }
+    function compareItems(a, b) {
+        let res = compare(a.symbol.name, b.symbol.name);
+        if (res === 0) {
+            res = a.symbol.kind - b.symbol.kind;
+        }
+        if (res === 0) {
+            res = compare(( a.symbol.location.uri.toString()), ( b.symbol.location.uri.toString()));
+        }
+        if (res === 0) {
+            if (a.symbol.location.range && b.symbol.location.range) {
+                if (!Range.areIntersecting(a.symbol.location.range, b.symbol.location.range)) {
+                    res = Range.compareRangesUsingStarts(a.symbol.location.range, b.symbol.location.range);
+                }
+            }
+            else if (a.provider.resolveWorkspaceSymbol && !b.provider.resolveWorkspaceSymbol) {
+                res = -1;
+            }
+            else if (!a.provider.resolveWorkspaceSymbol && b.provider.resolveWorkspaceSymbol) {
+                res = 1;
+            }
+        }
+        if (res === 0) {
+            res = compare(a.symbol.containerName ?? '', b.symbol.containerName ?? '');
+        }
+        return res;
+    }
+    return ( groupBy(all, compareItems).map(group => group[0])).flat();
+}
+function getOutOfWorkspaceEditorResources(accessor) {
+    const editorService = accessor.get(IEditorService);
+    const contextService = accessor.get(IWorkspaceContextService);
+    const fileService = accessor.get(IFileService);
+    const resources = ( editorService.editors
+        .map(
+        editor => EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
+    ))
+        .filter(resource => !!resource && !contextService.isInsideWorkspace(resource) && fileService.hasProvider(resource));
+    return resources;
+}
+const LINE_COLON_PATTERN = /\s?[#:\(](?:line )?(\d*)(?:[#:,](\d*))?\)?\s*$/;
+function extractRangeFromFilter(filter, unless) {
+    if (!filter || unless?.some(value => filter.indexOf(value) !== -1)) {
+        return undefined;
+    }
+    let range = undefined;
+    const patternMatch = LINE_COLON_PATTERN.exec(filter);
+    if (patternMatch) {
+        const startLineNumber = parseInt(patternMatch[1] ?? '', 10);
+        if (isNumber(startLineNumber)) {
+            range = {
+                startLineNumber: startLineNumber,
+                startColumn: 1,
+                endLineNumber: startLineNumber,
+                endColumn: 1
+            };
+            const startColumn = parseInt(patternMatch[2] ?? '', 10);
+            if (isNumber(startColumn)) {
+                range = {
+                    startLineNumber: range.startLineNumber,
+                    startColumn: startColumn,
+                    endLineNumber: range.endLineNumber,
+                    endColumn: startColumn
+                };
+            }
+        }
+        else if (patternMatch[1] === '') {
+            range = {
+                startLineNumber: 1,
+                startColumn: 1,
+                endLineNumber: 1,
+                endColumn: 1
+            };
+        }
+    }
+    if (patternMatch && range) {
+        return {
+            filter: filter.substr(0, patternMatch.index),
+            range
+        };
+    }
+    return undefined;
+}
+export { WorkspaceSymbolItem, WorkspaceSymbolProviderRegistry, extractRangeFromFilter, getOutOfWorkspaceEditorResources, getWorkspaceSymbols };

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

@@ -0,0 +1,385 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import { ConfiguringTask, ContributedTask, CustomTask } from '../common/tasks.js';
+import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import { ITaskService } from '../common/taskService.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { getColorStyleElement, getColorClass } from '../../terminal/browser/terminalIcon.js';
+import { showWithPinnedItems } from '../../../../platform/quickinput/browser/quickPickPin.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+const QUICKOPEN_DETAIL_CONFIG = 'task.quickOpen.detail';
+const QUICKOPEN_SKIP_CONFIG = 'task.quickOpen.skip';
+const SHOW_ALL = ( nls.localize('taskQuickPick.showAll', "Show All Tasks..."));
+const configureTaskIcon = registerIcon('tasks-list-configure', Codicon.gear, ( nls.localize('configureTaskIcon', 'Configuration icon in the tasks selection list.')));
+const removeTaskIcon = registerIcon('tasks-remove', Codicon.close, ( nls.localize('removeTaskIcon', 'Icon for remove in the tasks selection list.')));
+const runTaskStorageKey = 'runTaskStorageKey';
+let TaskQuickPick = 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 = objects.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();
+            const styleElement = getColorStyleElement(colorTheme);
+            entry.iconClasses = [getColorClass(task.configurationProperties.icon.color)];
+            document.body.appendChild(styleElement);
+        }
+    }
+    _createTaskEntry(task, extraButtons = []) {
+        const buttons = [
+            { iconClass: ThemeIcon.asClassName(configureTaskIcon), tooltip: ( nls.localize('configureTask', "Configure Task")) },
+            ...extraButtons
+        ];
+        const entry = { label: TaskQuickPick.getTaskLabelWithIcon(task, this._guessTaskLabel(task)), description: this._taskService.getTaskDescription(task), task, detail: this._showDetail() ? task.configurationProperties.detail : undefined, buttons };
+        TaskQuickPick.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: ( nls.localize('contributedTasks', "contributed")) });
+        types.forEach(type => {
+            entries.push({ label: `$(folder) ${type}`, task: type, ariaLabel: ( nls.localize('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].getRecentlyUsedKey();
+            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.getRecentlyUsedKey() === 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: ( nls.localize('removeRecent', 'Remove Recently Used Task'))
+            };
+            this._createEntriesForGroup(this._topLevelEntries, recentTasks, ( nls.localize('recentlyUsed', 'recently used')), [removeRecentButton]);
+        }
+        if (configuredTasks.length > 0) {
+            if (dedupedConfiguredTasks.length > 0) {
+                this._createEntriesForGroup(this._topLevelEntries, dedupedConfiguredTasks, ( nls.localize('configured', 'configured')));
+            }
+        }
+        if (defaultEntry && (configuredTasks.length === 0)) {
+            this._topLevelEntries.push({ type: 'separator', label: ( nls.localize('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: ( nls.localize(
+                '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: ( nls.localize('TaskQuickPick.changeSettingNo', "No"))
+        });
+        if (confirmed) {
+            await this._configurationService.updateValue(`${selectedType}.autoDetect`, 'on');
+            await ( new Promise(resolve => setTimeout(() => resolve(), 100)));
+            return this.show(( nls.localize('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 && !types.isString(task)) ? task.getRecentlyUsedKey() : 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 (types.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 && types.isString(selectedEntry.settingType)) {
+                    picker.dispose();
+                    return this.handleSettingOption(selectedEntry.settingType);
+                }
+                else {
+                    picker.dispose();
+                    return (selectedEntry?.task && !types.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.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.getSettingEntry(configurationService, 'grunt');
+        if (gruntEntry) {
+            entries.push(gruntEntry);
+        }
+        const gulpEntry = TaskQuickPick.getSettingEntry(configurationService, 'gulp');
+        if (gulpEntry) {
+            entries.push(gulpEntry);
+        }
+        const jakeEntry = TaskQuickPick.getSettingEntry(configurationService, 'jake');
+        if (jakeEntry) {
+            entries.push(jakeEntry);
+        }
+        return entries;
+    }
+    static getSettingEntry(configurationService, type) {
+        if (configurationService.getValue(`${type}.autoDetect`) === 'off') {
+            return {
+                label: ( nls.localize(
+                    '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: ( nls.localize('TaskQuickPick.goBack', 'Go back ↩')),
+                task: null,
+                alwaysShow: true
+            });
+        }
+        else {
+            taskQuickPickEntries = [{
+                    label: ( nls.localize('TaskQuickPick.noTasksForType', 'No {0} tasks found. Go back ↩', type)),
+                    task: null,
+                    alwaysShow: true
+                }];
+        }
+        const settingEntry = TaskQuickPick.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(( nls.localize(
+                'noProviderForTask',
+                "There is no task provider registered for tasks of type \"{0}\".",
+                task.type
+            )));
+        }
+        return resolvedTask;
+    }
+};
+TaskQuickPick = ( __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 };