@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.1

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

@@ -1,386 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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 '../../../../../../../override/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';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.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 };

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

@@ -1,109 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { PickerQuickAccessProvider, TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
-import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-import { ITaskService } from '../common/taskService.js';
-import { ContributedTask, CustomTask, ConfiguringTask } from '../common/tasks.js';
-import { TaskQuickPick } from './taskQuickPick.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-let TasksQuickAccessProvider = class TasksQuickAccessProvider extends PickerQuickAccessProvider {
-    static { this.PREFIX = 'task '; }
-    constructor(extensionService, _taskService, _configurationService, _quickInputService, _notificationService, _dialogService, _themeService, _storageService) {
-        super(TasksQuickAccessProvider.PREFIX, {
-            noResultsPick: {
-                label: ( localize('noTaskResults', "No matching tasks"))
-            }
-        });
-        this._taskService = _taskService;
-        this._configurationService = _configurationService;
-        this._quickInputService = _quickInputService;
-        this._notificationService = _notificationService;
-        this._dialogService = _dialogService;
-        this._themeService = _themeService;
-        this._storageService = _storageService;
-    }
-    async _getPicks(filter, disposables, token) {
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const taskQuickPick = ( new TaskQuickPick(
-            this._taskService,
-            this._configurationService,
-            this._quickInputService,
-            this._notificationService,
-            this._themeService,
-            this._dialogService,
-            this._storageService
-        ));
-        const topLevelPicks = await taskQuickPick.getTopLevelEntries();
-        const taskPicks = [];
-        for (const entry of topLevelPicks.entries) {
-            const highlights = matchesFuzzy(filter, entry.label);
-            if (!highlights) {
-                continue;
-            }
-            if (entry.type === 'separator') {
-                taskPicks.push(entry);
-            }
-            const task = entry.task;
-            const quickAccessEntry = entry;
-            quickAccessEntry.highlights = { label: highlights };
-            quickAccessEntry.trigger = (index) => {
-                if ((index === 1) && (quickAccessEntry.buttons?.length === 2)) {
-                    const key = (task && !isString(task)) ? task.getRecentlyUsedKey() : undefined;
-                    if (key) {
-                        this._taskService.removeRecentlyUsedTask(key);
-                    }
-                    return TriggerAction.REFRESH_PICKER;
-                }
-                else {
-                    if (ContributedTask.is(task)) {
-                        this._taskService.customize(task, undefined, true);
-                    }
-                    else if (CustomTask.is(task)) {
-                        this._taskService.openConfig(task);
-                    }
-                    return TriggerAction.CLOSE_PICKER;
-                }
-            };
-            quickAccessEntry.accept = async () => {
-                if (isString(task)) {
-                    const showResult = await taskQuickPick.show(( localize('TaskService.pickRunTask', 'Select the task to run')), undefined, task);
-                    if (showResult) {
-                        this._taskService.run(showResult, { attachProblemMatcher: true });
-                    }
-                }
-                else {
-                    this._taskService.run(await this._toTask(task), { attachProblemMatcher: true });
-                }
-            };
-            taskPicks.push(quickAccessEntry);
-        }
-        return taskPicks;
-    }
-    async _toTask(task) {
-        if (!ConfiguringTask.is(task)) {
-            return task;
-        }
-        return this._taskService.tryResolveTask(task);
-    }
-};
-TasksQuickAccessProvider = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, ITaskService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IDialogService)),
-    ( __param(6, IThemeService)),
-    ( __param(7, IStorageService))
-], TasksQuickAccessProvider));
-export { TasksQuickAccessProvider };