@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/searchEditor/browser/searchEditorSerialization.js

@@ -0,0 +1,268 @@
+import { coalesce, flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import './media/searchEditor.css.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { searchMatchComparer } from '../../search/browser/searchModel.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+const lineDelimiter = '\n';
+const translateRangeLines = (n) => (range) => ( new Range(
+    range.startLineNumber + n,
+    range.startColumn,
+    range.endLineNumber + n,
+    range.endColumn
+));
+const matchToSearchResultFormat = (match, longestLineNumber) => {
+    const getLinePrefix = (i) => `${match.range().startLineNumber + i}`;
+    const fullMatchLines = match.fullPreviewLines();
+    const results = [];
+    fullMatchLines
+        .forEach((sourceLine, i) => {
+        const lineNumber = getLinePrefix(i);
+        const paddingStr = ' '.repeat(longestLineNumber - lineNumber.length);
+        const prefix = `  ${paddingStr}${lineNumber}: `;
+        const prefixOffset = prefix.length;
+        const line = prefix + (sourceLine.split(/\r?\n?$/, 1)[0] || '');
+        const rangeOnThisLine = ({ start, end }) => ( new Range(
+            1,
+            (start ?? 1) + prefixOffset,
+            1,
+            (end ?? sourceLine.length + 1) + prefixOffset
+        ));
+        const matchRange = match.rangeInPreview();
+        const matchIsSingleLine = matchRange.startLineNumber === matchRange.endLineNumber;
+        let lineRange;
+        if (matchIsSingleLine) {
+            lineRange = (rangeOnThisLine({ start: matchRange.startColumn, end: matchRange.endColumn }));
+        }
+        else if (i === 0) {
+            lineRange = (rangeOnThisLine({ start: matchRange.startColumn }));
+        }
+        else if (i === fullMatchLines.length - 1) {
+            lineRange = (rangeOnThisLine({ end: matchRange.endColumn }));
+        }
+        else {
+            lineRange = (rangeOnThisLine({}));
+        }
+        results.push({ lineNumber: lineNumber, line, ranges: [lineRange] });
+    });
+    return results;
+};
+function fileMatchToSearchResultFormat(fileMatch, labelFormatter) {
+    const textSerializations = fileMatch.textMatches().length > 0 ? matchesToSearchResultFormat(fileMatch.resource, fileMatch.textMatches().sort(searchMatchComparer), fileMatch.context, labelFormatter) : undefined;
+    const cellSerializations = ( fileMatch.cellMatches().sort((a, b) => a.cellIndex - b.cellIndex).sort().filter(cellMatch => cellMatch.contentMatches.length > 0).map(
+        (cellMatch, index) => cellMatchToSearchResultFormat(cellMatch, labelFormatter, index === 0)
+    ));
+    return [textSerializations, ...cellSerializations].filter(x => !!x);
+}
+function matchesToSearchResultFormat(resource, sortedMatches, matchContext, labelFormatter, shouldUseHeader = true) {
+    const longestLineNumber = ( sortedMatches[sortedMatches.length - 1].range().endLineNumber.toString()).length;
+    const text = shouldUseHeader ? [`${labelFormatter(resource)}:`] : [];
+    const matchRanges = [];
+    const targetLineNumberToOffset = {};
+    const context = [];
+    matchContext.forEach((line, lineNumber) => context.push({ line, lineNumber }));
+    context.sort((a, b) => a.lineNumber - b.lineNumber);
+    let lastLine = undefined;
+    const seenLines = ( new Set());
+    sortedMatches.forEach(match => {
+        matchToSearchResultFormat(match, longestLineNumber).forEach(match => {
+            if (!( seenLines.has(match.lineNumber))) {
+                while (context.length && context[0].lineNumber < +match.lineNumber) {
+                    const { line, lineNumber } = context.shift();
+                    if (lastLine !== undefined && lineNumber !== lastLine + 1) {
+                        text.push('');
+                    }
+                    text.push(`  ${' '.repeat(longestLineNumber - `${lineNumber}`.length)}${lineNumber}  ${line}`);
+                    lastLine = lineNumber;
+                }
+                targetLineNumberToOffset[match.lineNumber] = text.length;
+                seenLines.add(match.lineNumber);
+                text.push(match.line);
+                lastLine = +match.lineNumber;
+            }
+            matchRanges.push(...( match.ranges.map(translateRangeLines(targetLineNumberToOffset[match.lineNumber]))));
+        });
+    });
+    while (context.length) {
+        const { line, lineNumber } = context.shift();
+        text.push(`  ${lineNumber}  ${line}`);
+    }
+    return { text, matchRanges };
+}
+function cellMatchToSearchResultFormat(cellMatch, labelFormatter, shouldUseHeader) {
+    return matchesToSearchResultFormat(cellMatch.cell.uri, cellMatch.contentMatches.sort(searchMatchComparer), cellMatch.context, labelFormatter, shouldUseHeader);
+}
+const contentPatternToSearchConfiguration = (pattern, includes, excludes, contextLines) => {
+    return {
+        query: pattern.contentPattern.pattern,
+        isRegexp: !!pattern.contentPattern.isRegExp,
+        isCaseSensitive: !!pattern.contentPattern.isCaseSensitive,
+        matchWholeWord: !!pattern.contentPattern.isWordMatch,
+        filesToExclude: excludes, filesToInclude: includes,
+        showIncludesExcludes: !!(includes || excludes || pattern?.userDisabledExcludesAndIgnoreFiles),
+        useExcludeSettingsAndIgnoreFiles: (pattern?.userDisabledExcludesAndIgnoreFiles === undefined ? true : !pattern.userDisabledExcludesAndIgnoreFiles),
+        contextLines,
+        onlyOpenEditors: !!pattern.onlyOpenEditors,
+        notebookSearchConfig: {
+            includeMarkupInput: !!pattern.contentPattern.notebookInfo?.isInNotebookMarkdownInput,
+            includeMarkupPreview: !!pattern.contentPattern.notebookInfo?.isInNotebookMarkdownPreview,
+            includeCodeInput: !!pattern.contentPattern.notebookInfo?.isInNotebookCellInput,
+            includeOutput: !!pattern.contentPattern.notebookInfo?.isInNotebookCellOutput,
+        }
+    };
+};
+const serializeSearchConfiguration = (config) => {
+    const removeNullFalseAndUndefined = (a) => a.filter(a => a !== false && a !== null && a !== undefined);
+    const escapeNewlines = (str) => str.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
+    return removeNullFalseAndUndefined([
+        `# Query: ${escapeNewlines(config.query ?? '')}`,
+        (config.isCaseSensitive || config.matchWholeWord || config.isRegexp || config.useExcludeSettingsAndIgnoreFiles === false)
+            && `# Flags: ${coalesce([
+                config.isCaseSensitive && 'CaseSensitive',
+                config.matchWholeWord && 'WordMatch',
+                config.isRegexp && 'RegExp',
+                config.onlyOpenEditors && 'OpenEditors',
+                (config.useExcludeSettingsAndIgnoreFiles === false) && 'IgnoreExcludeSettings'
+            ]).join(' ')}`,
+        config.filesToInclude ? `# Including: ${config.filesToInclude}` : undefined,
+        config.filesToExclude ? `# Excluding: ${config.filesToExclude}` : undefined,
+        config.contextLines ? `# ContextLines: ${config.contextLines}` : undefined,
+        ''
+    ]).join(lineDelimiter);
+};
+const defaultSearchConfig = () => ({
+    query: '',
+    filesToInclude: '',
+    filesToExclude: '',
+    isRegexp: false,
+    isCaseSensitive: false,
+    useExcludeSettingsAndIgnoreFiles: true,
+    matchWholeWord: false,
+    contextLines: 0,
+    showIncludesExcludes: false,
+    onlyOpenEditors: false,
+    notebookSearchConfig: {
+        includeMarkupInput: true,
+        includeMarkupPreview: false,
+        includeCodeInput: true,
+        includeOutput: true,
+    }
+});
+const extractSearchQueryFromLines = (lines) => {
+    const query = defaultSearchConfig();
+    const unescapeNewlines = (str) => {
+        let out = '';
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] === '\\') {
+                i++;
+                const escaped = str[i];
+                if (escaped === 'n') {
+                    out += '\n';
+                }
+                else if (escaped === '\\') {
+                    out += '\\';
+                }
+                else {
+                    throw Error(localize('invalidQueryStringError', "All backslashes in Query string must be escaped (\\\\)"));
+                }
+            }
+            else {
+                out += str[i];
+            }
+        }
+        return out;
+    };
+    const parseYML = /^# ([^:]*): (.*)$/;
+    for (const line of lines) {
+        const parsed = parseYML.exec(line);
+        if (!parsed) {
+            continue;
+        }
+        const [, key, value] = parsed;
+        switch (key) {
+            case 'Query':
+                query.query = unescapeNewlines(value);
+                break;
+            case 'Including':
+                query.filesToInclude = value;
+                break;
+            case 'Excluding':
+                query.filesToExclude = value;
+                break;
+            case 'ContextLines':
+                query.contextLines = +value;
+                break;
+            case 'Flags': {
+                query.isRegexp = value.indexOf('RegExp') !== -1;
+                query.isCaseSensitive = value.indexOf('CaseSensitive') !== -1;
+                query.useExcludeSettingsAndIgnoreFiles = value.indexOf('IgnoreExcludeSettings') === -1;
+                query.matchWholeWord = value.indexOf('WordMatch') !== -1;
+                query.onlyOpenEditors = value.indexOf('OpenEditors') !== -1;
+            }
+        }
+    }
+    query.showIncludesExcludes = !!(query.filesToInclude || query.filesToExclude || !query.useExcludeSettingsAndIgnoreFiles);
+    return query;
+};
+const serializeSearchResultForEditor = (searchResult, rawIncludePattern, rawExcludePattern, contextLines, labelFormatter, sortOrder, limitHit) => {
+    if (!searchResult.query) {
+        throw Error('Internal Error: Expected query, got null');
+    }
+    const config = contentPatternToSearchConfiguration(searchResult.query, rawIncludePattern, rawExcludePattern, contextLines);
+    const filecount = searchResult.fileCount() > 1 ? ( localize('numFiles', "{0} files", searchResult.fileCount())) : ( localize('oneFile', "1 file"));
+    const resultcount = searchResult.count() > 1 ? ( localize('numResults', "{0} results", searchResult.count())) : ( localize('oneResult', "1 result"));
+    const info = [
+        searchResult.count()
+            ? `${resultcount} - ${filecount}`
+            : ( localize('noResults', "No Results")),
+    ];
+    if (limitHit) {
+        info.push(( localize(
+            'searchMaxResultsWarning',
+            "The result set only contains a subset of all matches. Be more specific in your search to narrow down the results."
+        )));
+    }
+    info.push('');
+    const matchComparer = (a, b) => searchMatchComparer(a, b, sortOrder);
+    const allResults = flattenSearchResultSerializations(flatten(( searchResult.folderMatches().sort(matchComparer)
+        .map(folderMatch => folderMatch.allDownstreamFileMatches().sort(matchComparer)
+        .flatMap(fileMatch => fileMatchToSearchResultFormat(fileMatch, labelFormatter))))));
+    return {
+        matchRanges: ( allResults.matchRanges.map(translateRangeLines(info.length))),
+        text: info.concat(allResults.text).join(lineDelimiter),
+        config
+    };
+};
+const flattenSearchResultSerializations = (serializations) => {
+    const text = [];
+    const matchRanges = [];
+    serializations.forEach(serialized => {
+        ( serialized.matchRanges.map(translateRangeLines(text.length))).forEach(range => matchRanges.push(range));
+        serialized.text.forEach(line => text.push(line));
+        text.push('');
+    });
+    return { text, matchRanges };
+};
+const parseSavedSearchEditor = async (accessor, resource) => {
+    const textFileService = accessor.get(ITextFileService);
+    const text = (await textFileService.read(resource)).value;
+    return parseSerializedSearchEditor(text);
+};
+const parseSerializedSearchEditor = (text) => {
+    const headerlines = [];
+    const bodylines = [];
+    let inHeader = true;
+    for (const line of text.split(/\r?\n/g)) {
+        if (inHeader) {
+            headerlines.push(line);
+            if (line === '') {
+                inHeader = false;
+            }
+        }
+        else {
+            bodylines.push(line);
+        }
+    }
+    return { config: extractSearchQueryFromLines(headerlines), text: bodylines.join('\n') };
+};
+export { defaultSearchConfig, extractSearchQueryFromLines, parseSavedSearchEditor, parseSerializedSearchEditor, serializeSearchConfiguration, serializeSearchResultForEditor };

package/dist/vscode/vs/workbench/contrib/snippets/browser/tabCompletion.js

@@ -23,7 +23,7 @@ let TabCompletionController = class TabCompletionController {
         this._activeSnippets = [];
         this._hasSnippets = TabCompletionController.ContextKey.bindTo(contextKeyService);
         this._configListener = this._editor.onDidChangeConfiguration(e => {
-            if (e.hasChanged(118 )) {
+            if (e.hasChanged(119 )) {
                 this._update();
             }
         });
@@ -34,7 +34,7 @@ let TabCompletionController = class TabCompletionController {
         this._selectionListener?.dispose();
     }
     _update() {
-        const enabled = this._editor.getOption(118 ) === 'onlySnippets';
+        const enabled = this._editor.getOption(119 ) === 'onlySnippets';
         if (this._enabled !== enabled) {
             this._enabled = enabled;
             if (!this._enabled) {

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 };