@theia/task 1.37.0-next.8 → 1.37.0

package/src/browser/quick-open-task.ts

@@ -16,17 +16,19 @@
 
 import { inject, injectable, optional } from '@theia/core/shared/inversify';
 import { TaskService } from './task-service';
-import { TaskInfo, TaskConfiguration, TaskCustomization, TaskScope, TaskConfigurationScope } from '../common/task-protocol';
+import { TaskInfo, TaskConfiguration, TaskCustomization, TaskScope, TaskConfigurationScope, TaskDefinition } from '../common/task-protocol';
 import { TaskDefinitionRegistry } from './task-definition-registry';
 import URI from '@theia/core/lib/common/uri';
-import { LabelProvider, QuickAccessProvider, QuickAccessRegistry, QuickInputService, PreferenceService } from '@theia/core/lib/browser';
+import { LabelProvider, QuickAccessProvider, QuickAccessRegistry, QuickInputService, QuickPick, PreferenceService } from '@theia/core/lib/browser';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
 import { TaskNameResolver } from './task-name-resolver';
 import { TaskSourceResolver } from './task-source-resolver';
 import { TaskConfigurationManager } from './task-configuration-manager';
-import { filterItems, QuickInputButton, QuickPickItem, QuickPickItemOrSeparator, QuickPicks } from '@theia/core/lib/browser/quick-input/quick-input-service';
+import { filterItems, QuickInputButton, QuickPickItem, QuickPickItemOrSeparator, QuickPicks, QuickPickInput, QuickPickValue } from
+    '@theia/core/lib/browser/quick-input/quick-input-service';
 import { CancellationToken } from '@theia/core/lib/common';
+import { nls } from '@theia/core/lib/common/nls';
 import { TriggerAction } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/browser/pickerQuickAccess';
 
 export namespace ConfigureTaskAction {
@@ -34,11 +36,21 @@ export namespace ConfigureTaskAction {
     export const TEXT = 'Configure Task';
 }
 
+export type TaskEntry = QuickPickItemOrSeparator | QuickPickValue<string>;
+export namespace TaskEntry {
+    export function isQuickPickValue(item: QuickPickItemOrSeparator | QuickPickValue<String>): item is QuickPickValue<string> {
+        return 'value' in item && typeof item.value === 'string';
+    }
+}
+
+export const CHOOSE_TASK = nls.localizeByDefault('Select the task to run');
+export const NO_TASK_TO_RUN = nls.localize('theia/task/noTaskToRun', 'No task to run found. Configure Tasks...');
+
 @injectable()
 export class QuickOpenTask implements QuickAccessProvider {
     static readonly PREFIX = 'task ';
     readonly description: string = 'Run Task';
-    protected items: Array<QuickPickItemOrSeparator> = [];
+    protected items: Array<TaskEntry> = [];
 
     @inject(TaskService)
     protected readonly taskService: TaskService;
@@ -77,21 +89,61 @@ export class QuickOpenTask implements QuickAccessProvider {
     protected async doInit(token: number): Promise<void> {
         const recentTasks = this.taskService.recentTasks;
         const configuredTasks = await this.taskService.getConfiguredTasks(token);
-        const providedTasks = await this.taskService.getProvidedTasks(token);
+        const providedTypes = this.taskDefinitionRegistry.getAll();
 
-        const { filteredRecentTasks, filteredConfiguredTasks, filteredProvidedTasks } = this.getFilteredTasks(recentTasks, configuredTasks, providedTasks);
+        const { filteredRecentTasks, filteredConfiguredTasks } = this.getFilteredTasks(recentTasks, configuredTasks, []);
         const isMulti: boolean = this.workspaceService.isMultiRootWorkspaceOpened;
         this.items = [];
 
         const filteredRecentTasksItems = this.getItems(filteredRecentTasks, 'recently used tasks', token, isMulti);
         const filteredConfiguredTasksItems = this.getItems(filteredConfiguredTasks, 'configured tasks', token, isMulti);
-        const filteredProvidedTasksItems = this.getItems(filteredProvidedTasks, 'detected tasks', token, isMulti);
+        const providedTypeItems = this.createProvidedTypeItems(providedTypes);
 
         this.items.push(
             ...filteredRecentTasksItems,
             ...filteredConfiguredTasksItems,
-            ...filteredProvidedTasksItems
+            ...providedTypeItems
         );
+
+        if (!this.items.length) {
+            this.items.push(({
+                label: NO_TASK_TO_RUN,
+                execute: () => this.configure()
+            }));
+        }
+    }
+
+    protected createProvidedTypeItems(providedTypes: TaskDefinition[]): TaskEntry[] {
+        const result: TaskEntry[] = [];
+        result.push({ type: 'separator', label: nls.localizeByDefault('contributed') });
+
+        for (const definition of providedTypes) {
+            const type = definition.taskType;
+            result.push({
+                label: `$(folder) ${type}`,
+                value: type,
+                /**
+                 * This function is used in the context of a QuickAccessProvider (triggered from the command palette: '?task').
+                 * It triggers a call to QuickOpenTask#getPicks,
+                 * the 'execute' function below is called when the user selects an entry for a task type which triggers the display of
+                 * the second level quick pick.
+                 *
+                 * Due to the asynchronous resolution of second-level tasks, there may be a delay in showing the quick input widget.
+                 *
+                 * NOTE: The widget is not delayed in other contexts e.g. by commands (Run Tasks), see the implementation at QuickOpenTask#open
+                 *
+                 * To improve the performance, we may consider using a `PickerQuickAccessProvider` instead of a `QuickAccessProvider`,
+                 * and support providing 'FastAndSlowPicks'.
+                 *
+                 * TODO: Consider the introduction and exposure of monaco `PickerQuickAccessProvider` and the corresponding refactoring for this and other
+                 * users of QuickAccessProvider.
+                 */
+                execute: () => {
+                    this.doSecondLevel(type);
+                }
+            });
+        }
+        return result;
     }
 
     protected onDidTriggerGearIcon(item: QuickPickItem): void {
@@ -102,17 +154,54 @@ export class QuickOpenTask implements QuickAccessProvider {
     }
 
     async open(): Promise<void> {
+        this.showMultiLevelQuickPick();
+    }
+
+    async showMultiLevelQuickPick(): Promise<void> {
         await this.init();
-        if (!this.items.length) {
-            this.items.push(({
-                label: 'No task to run found. Configure Tasks...',
+        const picker: QuickPick<TaskEntry> = this.quickInputService.createQuickPick();
+        picker.placeholder = CHOOSE_TASK;
+        picker.matchOnDescription = true;
+        picker.ignoreFocusOut = false;
+        picker.items = this.items;
+
+        const firstLevelTask = await this.doPickerFirstLevel(picker);
+
+        if (!!firstLevelTask && TaskEntry.isQuickPickValue(firstLevelTask)) {
+            // A taskType was selected
+            picker.busy = true;
+            await this.doSecondLevel(firstLevelTask.value);
+        } else if (!!firstLevelTask && 'execute' in firstLevelTask && typeof firstLevelTask.execute === 'function') {
+            firstLevelTask.execute();
+        }
+        picker.dispose();
+    }
+
+    protected async doPickerFirstLevel(picker: QuickPick<TaskEntry>): Promise<TaskEntry | undefined> {
+        picker.show();
+        const firstLevelPickerResult = await new Promise<TaskEntry | undefined | null>(resolve => {
+            picker.onDidAccept(async () => {
+                resolve(picker.selectedItems ? picker.selectedItems[0] : undefined);
+            });
+        });
+        return firstLevelPickerResult ?? undefined;
+    }
+
+    protected async doSecondLevel(taskType: string): Promise<void> {
+        // Resolve Second level tasks based on selected TaskType
+        const isMulti = this.workspaceService.isMultiRootWorkspaceOpened;
+        const token = this.taskService.startUserAction();
+        const providedTasks = await this.taskService.getProvidedTasks(token, taskType);
+        const providedTasksItems = this.getItems(providedTasks, taskType + ' tasks', token, isMulti);
+
+        if (!providedTasksItems.length) {
+            providedTasksItems.push(({
+                label: NO_TASK_TO_RUN,
                 execute: () => this.configure()
             }));
         }
-        this.quickInputService?.showQuickPick(this.items, {
-            placeholder: 'Select the task to run',
-            onDidTriggerItemButton: ({ item }) => this.onDidTriggerGearIcon(item)
-        });
+
+        this.quickInputService?.showQuickPick(providedTasksItems, { placeholder: CHOOSE_TASK });
     }
 
     attach(): void {
@@ -145,17 +234,26 @@ export class QuickOpenTask implements QuickAccessProvider {
                     label: 'No tasks found'
                 }));
             }
-            this.quickInputService?.showQuickPick(this.items, { placeholder: 'Choose task to open' });
+            this.quickInputService?.showQuickPick(this.items, { placeholder: CHOOSE_TASK });
         });
     }
 
     async configure(): Promise<void> {
-        this.items = [];
+        this.quickInputService?.pick(this.resolveItemsToConfigure(), { placeHolder: nls.localizeByDefault('Select a task to configure') }).
+            then(async item => {
+                if (item && 'execute' in item && typeof item.execute === 'function') {
+                    item.execute();
+                }
+            });
+    }
+
+    protected async resolveItemsToConfigure(): Promise<QuickPickInput<QuickPickItemOrSeparator>[]>  {
+        const items: Array<QuickPickInput<QuickPickItemOrSeparator>> = [];
         const isMulti: boolean = this.workspaceService.isMultiRootWorkspaceOpened;
         const token: number = this.taskService.startUserAction();
 
         const configuredTasks = await this.taskService.getConfiguredTasks(token);
-        const providedTasks = await this.taskService.getProvidedTasks(token);
+        const providedTasks = await this.taskService.getProvidedTasks(token, '*');
 
         // check if tasks.json exists. If not, display "Create tasks.json file from template"
         // If tasks.json exists and empty, display 'Open tasks.json file'
@@ -163,7 +261,7 @@ export class QuickOpenTask implements QuickAccessProvider {
         const groupedTasks = this.getGroupedTasksByWorkspaceFolder([...filteredConfiguredTasks, ...filteredProvidedTasks]);
         if (groupedTasks.has(TaskScope.Global.toString())) {
             const configs = groupedTasks.get(TaskScope.Global.toString())!;
-            this.items.push(
+            items.push(
                 ...configs.map(taskConfig => {
                     const item = new TaskConfigureQuickOpenItem(
                         token,
@@ -184,7 +282,7 @@ export class QuickOpenTask implements QuickAccessProvider {
             const folderName = new URI(rootFolder).displayName;
             if (groupedTasks.has(rootFolder)) {
                 const configs = groupedTasks.get(rootFolder.toString())!;
-                this.items.push(
+                items.push(
                     ...configs.map((taskConfig, index) => {
                         const item = new TaskConfigureQuickOpenItem(
                             token,
@@ -202,28 +300,28 @@ export class QuickOpenTask implements QuickAccessProvider {
             } else {
                 const { configUri } = this.preferences.resolve('tasks', [], rootFolder);
                 const existTaskConfigFile = !!configUri;
-                this.items.push(({
+                items.push(({
                     label: existTaskConfigFile ? 'Open tasks.json file' : 'Create tasks.json file from template',
                     execute: () => {
                         setTimeout(() => this.taskConfigurationManager.openConfiguration(rootFolder));
                     }
                 }));
             }
-            if (this.items.length > 0) {
-                this.items.unshift({
+            if (items.length > 0) {
+                items.unshift({
                     type: 'separator',
                     label: isMulti ? folderName : ''
                 });
             }
         }
 
-        if (this.items.length === 0) {
-            this.items.push(({
+        if (items.length === 0) {
+            items.push(({
                 label: 'No tasks found'
             }));
         }
 
-        this.quickInputService?.showQuickPick(this.items, { placeholder: 'Select a task to configure' });
+        return items;
     }
 
     protected getTaskItems(): QuickPickItem[] {
@@ -297,9 +395,7 @@ export class QuickOpenTask implements QuickAccessProvider {
     }
 
     async getPicks(filter: string, token: CancellationToken): Promise<QuickPicks> {
-        if (this.items.length === 0) {
-            await this.init();
-        }
+        await this.init();
         return filterItems(this.items, filter);
     }
 
@@ -317,8 +413,8 @@ export class QuickOpenTask implements QuickAccessProvider {
     }
 
     private getItems(tasks: TaskConfiguration[], groupLabel: string, token: number, isMulti: boolean):
-        QuickPickItemOrSeparator[] {
-        const items: QuickPickItemOrSeparator[] = tasks.map(task =>
+        TaskEntry[] {
+        const items: TaskEntry[] = tasks.map(task =>
             new TaskRunQuickOpenItem(token, task, this.taskService, isMulti, this.taskDefinitionRegistry, this.taskNameResolver,
                 this.taskSourceResolver, this.taskConfigurationManager, [{
                     iconClass: 'codicon-gear',

package/src/browser/task-contribution.ts

@@ -81,6 +81,10 @@ export interface TaskProvider {
     provideTasks(): Promise<TaskConfiguration[]>;
 }
 
+export interface WillResolveTaskProvider extends WaitUntilEvent {
+    taskType?: string
+}
+
 /**
  * The {@link TaskResolverRegistry} is the common component for registration and provision of
  * {@link TaskResolver}s. Theia will collect all {@link TaskContribution}s and invoke {@link TaskContribution#registerResolvers}
@@ -89,7 +93,7 @@ export interface TaskProvider {
 @injectable()
 export class TaskResolverRegistry {
 
-    protected readonly onWillProvideTaskResolverEmitter = new Emitter<WaitUntilEvent>();
+    protected readonly onWillProvideTaskResolverEmitter = new Emitter<WillResolveTaskProvider>();
     /**
      * Emit when the registry provides a registered resolver. i.e. when the {@link TaskResolverRegistry#getResolver}
      * function is called.
@@ -156,7 +160,7 @@ export class TaskResolverRegistry {
      * @returns a promise of the registered `TaskResolver` or `undefined` if no resolver is registered for the given type.
      */
     async getTaskResolver(type: string): Promise<TaskResolver | undefined> {
-        await WaitUntilEvent.fire(this.onWillProvideTaskResolverEmitter, {});
+        await WaitUntilEvent.fire(this.onWillProvideTaskResolverEmitter, { taskType: type });
         return this.taskResolvers.get(type);
     }
 
@@ -200,7 +204,7 @@ export class TaskResolverRegistry {
 @injectable()
 export class TaskProviderRegistry {
 
-    protected readonly onWillProvideTaskProviderEmitter = new Emitter<WaitUntilEvent>();
+    protected readonly onWillProvideTaskProviderEmitter = new Emitter<WillResolveTaskProvider>();
     /**
      * Emit when the registry provides a registered task provider. i.e. when the {@link TaskProviderRegistry#getProvider}
      * function is called.
@@ -229,6 +233,14 @@ export class TaskProviderRegistry {
         };
     }
 
+    /**
+     * Initiates activation of a TaskProvider with the given type
+     * @param type the task configuration type, '*' indicates, all providers.
+     */
+    async activateProvider(type: string): Promise<void> {
+        await WaitUntilEvent.fire(this.onWillProvideTaskProviderEmitter, { taskType: type });
+    }
+
     /**
      * Retrieves the {@link TaskProvider} registered for the given type task configuration type.
      * If there is already a `TaskProvider` registered for the specified type the registration will
@@ -238,17 +250,17 @@ export class TaskProviderRegistry {
      * @returns a promise of the registered `TaskProvider`` or `undefined` if no provider is registered for the given type.
      */
     async getProvider(type: string): Promise<TaskProvider | undefined> {
-        await WaitUntilEvent.fire(this.onWillProvideTaskProviderEmitter, {});
+        await this.activateProvider(type);
         return this.providers.get(type);
     }
 
     /**
      * Retrieve all registered {@link TaskProvider}s.
      *
+     * Use {@link activateProvider} to control registration of providers as needed.
      * @returns a promise of all registered {@link TaskProvider}s.
      */
     async getProviders(): Promise<TaskProvider[]> {
-        await WaitUntilEvent.fire(this.onWillProvideTaskProviderEmitter, {});
         return [...this.providers.values()];
     }
 }

package/src/browser/task-service.ts

@@ -403,11 +403,14 @@ export class TaskService implements TaskConfigurationClient {
     }
 
     /**
-     * Returns an array of the task configurations which are provided by the extensions.
+     * Returns an array that contains the task configurations provided by the task providers for the specified task type.
      * @param token  The cache token for the user interaction in progress
+     * @param type The task type (filter) associated to the returning TaskConfigurations
+     *
+     * '*' indicates all tasks regardless of the type
      */
-    getProvidedTasks(token: number): Promise<TaskConfiguration[]> {
-        return this.providedTaskConfigurations.getTasks(token);
+    getProvidedTasks(token: number, type?: string): Promise<TaskConfiguration[]> {
+        return this.providedTaskConfigurations.getTasks(token, type);
     }
 
     addRecentTasks(tasks: TaskConfiguration | TaskConfiguration[]): void {