@theia/task 1.53.0-next.5 → 1.53.0-next.55

package/src/browser/task-contribution.ts

@@ -1,266 +1,266 @@
-// *****************************************************************************
-// Copyright (C) 2018 Red Hat, Inc. and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import { injectable, postConstruct } from '@theia/core/shared/inversify';
-import { Disposable } from '@theia/core/lib/common/disposable';
-import { TaskConfiguration } from '../common/task-protocol';
-import { WaitUntilEvent, Emitter } from '@theia/core/lib/common/event';
-
-export const TaskContribution = Symbol('TaskContribution');
-
-/**
- * A {@link TaskContribution} allows to contribute custom {@link TaskResolver}s and/or {@link TaskProvider}s.
- *
- *  ### Example usage
- * ```typescript
- * @injectable()
- * export class ProcessTaskContribution implements TaskContribution {
- *
- *     @inject(ProcessTaskResolver)
- *     protected readonly processTaskResolver: ProcessTaskResolver;
- *
- *     registerResolvers(resolvers: TaskResolverRegistry): void {
- *         resolvers.register('process', this.processTaskResolver);
- *         resolvers.register('shell', this.processTaskResolver);
- *     }
- * }
- * ```
- */
-export interface TaskContribution {
-    /**
-     * Register task resolvers using the given `TaskResolverRegistry`.
-     * @param resolvers the task resolver registry.
-     */
-    registerResolvers?(resolvers: TaskResolverRegistry): void;
-    /**
-     * Register task providers using the given `TaskProviderRegistry`.
-     * @param resolvers the task provider registry.
-     */
-    registerProviders?(providers: TaskProviderRegistry): void;
-}
-
-/**
- * A {@link TaskResolver} is used to preprocess/resolve a task before sending
- * it to the Task Server. For instance, the resolver can be used to add missing information to the configuration
- * (e.g default values for optional parameters).
- */
-export interface TaskResolver {
-    /**
-     * Resolves a `TaskConfiguration` before sending it for execution to the `TaskServer` (Backend).
-     * @param taskConfig the configuration that should be resolved.
-     *
-     * @returns a promise of the resolved `TaskConfiguration`.
-     */
-
-    resolveTask(taskConfig: TaskConfiguration): Promise<TaskConfiguration>;
-}
-
-/**
- * A {@link TaskProvider} can be used to define the set of tasks that should
- * be provided to the system. i.e. that are available for the user to run.
- */
-export interface TaskProvider {
-    /**
-     * Retrieves the task configurations which are provided programmatically to the system.
-     *
-     * @returns a promise of the provided tasks configurations.
-     */
-    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}
- * for each contribution.
- */
-@injectable()
-export class TaskResolverRegistry {
-
-    protected readonly onWillProvideTaskResolverEmitter = new Emitter<WillResolveTaskProvider>();
-    /**
-     * Emit when the registry provides a registered resolver. i.e. when the {@link TaskResolverRegistry#getResolver}
-     * function is called.
-     */
-    readonly onWillProvideTaskResolver = this.onWillProvideTaskResolverEmitter.event;
-
-    protected taskResolvers: Map<string, TaskResolver> = new Map();
-    protected executionResolvers: Map<string, TaskResolver> = new Map();
-
-    /**
-     * Registers the given {@link TaskResolver} to resolve the `TaskConfiguration` of the specified type.
-     * If there is already a `TaskResolver` registered for the specified type the registration will
-     * be overwritten with the new value.
-     *
-     * @deprecated since 1.12.0 use `registerTaskResolver` instead.
-     *
-     * @param type the task configuration type for which the given resolver should be registered.
-     * @param resolver the task resolver that should be registered.
-     *
-     * @returns a `Disposable` that can be invoked to unregister the given resolver
-     */
-    register(type: string, resolver: TaskResolver): Disposable {
-        return this.registerTaskResolver(type, resolver);
-    }
-
-    /**
-     * Registers the given {@link TaskResolver} to resolve the `TaskConfiguration` of the specified type.
-     * If there is already a `TaskResolver` registered for the specified type the registration will
-     * be overwritten with the new value.
-     *
-     * @param type the task configuration type for which the given resolver should be registered.
-     * @param resolver the task resolver that should be registered.
-     *
-     * @returns a `Disposable` that can be invoked to unregister the given resolver
-     */
-
-    registerTaskResolver(type: string, resolver: TaskResolver): Disposable {
-        if (this.taskResolvers.has(type)) {
-            console.warn(`Overriding task resolver for ${type}`);
-        }
-        this.taskResolvers.set(type, resolver);
-        return {
-            dispose: () => this.taskResolvers.delete(type)
-        };
-    }
-
-    /**
-     * Retrieves the {@link TaskResolver} registered for the given type task configuration type.
-     *
-     * @deprecated since 1.12.0 use `getTaskResolver()` instead.
-     *
-     * @param type the task configuration type
-     *
-     * @returns a promise of the registered `TaskResolver` or `undefined` if no resolver is registered for the given type.
-     */
-    async getResolver(type: string): Promise<TaskResolver | undefined> {
-        return this.getTaskResolver(type);
-    }
-
-    /**
-     * Retrieves the {@link TaskResolver} registered for the given type task configuration type.
-     * @param type the task configuration type
-     *
-     * @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, { taskType: type });
-        return this.taskResolvers.get(type);
-    }
-
-    /**
-     * Registers the given {@link TaskResolver} to resolve the `TaskConfiguration` for the
-     * specified type of execution ('shell', 'process' or 'customExecution').
-     * If there is already a `TaskResolver` registered for the specified type the registration will
-     * be overwritten with the new value.
-     *
-     * @param type the task execution type for which the given resolver should be registered.
-     * @param resolver the task resolver that should be registered.
-     *
-     * @returns a `Disposable` that can be invoked to unregister the given resolver
-     */
-    registerExecutionResolver(type: string, resolver: TaskResolver): Disposable {
-        if (this.executionResolvers.has(type)) {
-            console.warn(`Overriding execution resolver for ${type}`);
-        }
-        this.executionResolvers.set(type, resolver);
-        return {
-            dispose: () => this.executionResolvers.delete(type)
-        };
-    }
-
-    /**
-     * Retrieves the {@link TaskResolver} registered for the given type of execution ('shell', 'process' or 'customExecution')..
-     * @param type the task configuration type
-     *
-     * @returns a promise of the registered `TaskResolver` or `undefined` if no resolver is registered for the given type.
-     */
-    getExecutionResolver(executionType: string): TaskResolver | undefined {
-        return this.executionResolvers.get(executionType);
-    }
-}
-
-/**
- * The {@link TaskProviderRegistry} is the common component for registration and provision of
- * {@link TaskProvider}s. Theia will collect all {@link TaskContribution}s and invoke {@link TaskContribution#registerProviders}
- * for each contribution.
- */
-@injectable()
-export class TaskProviderRegistry {
-
-    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.
-     */
-    readonly onWillProvideTaskProvider = this.onWillProvideTaskProviderEmitter.event;
-
-    protected providers: Map<string, TaskProvider>;
-
-    @postConstruct()
-    protected init(): void {
-        this.providers = new Map();
-    }
-
-    /**
-     * Registers the given {@link TaskProvider} for task configurations of the specified type
-     * @param type the task configuration type for which the given provider should be registered.
-     * @param provider the `TaskProvider` that should be registered.
-     *
-     * @returns a `Disposable` that can be invoked to unregister the given resolver.
-     */
-    register(type: string, provider: TaskProvider, handle?: number): Disposable {
-        const key = handle === undefined ? type : `${type}::${handle}`;
-        this.providers.set(key, provider);
-        return {
-            dispose: () => this.providers.delete(key)
-        };
-    }
-
-    /**
-     * 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
-     * be overwritten with the new value.
-     * @param type the task configuration type.
-     *
-     * @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 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[]> {
-        return [...this.providers.values()];
-    }
-}
+// *****************************************************************************
+// Copyright (C) 2018 Red Hat, Inc. and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, postConstruct } from '@theia/core/shared/inversify';
+import { Disposable } from '@theia/core/lib/common/disposable';
+import { TaskConfiguration } from '../common/task-protocol';
+import { WaitUntilEvent, Emitter } from '@theia/core/lib/common/event';
+
+export const TaskContribution = Symbol('TaskContribution');
+
+/**
+ * A {@link TaskContribution} allows to contribute custom {@link TaskResolver}s and/or {@link TaskProvider}s.
+ *
+ *  ### Example usage
+ * ```typescript
+ * @injectable()
+ * export class ProcessTaskContribution implements TaskContribution {
+ *
+ *     @inject(ProcessTaskResolver)
+ *     protected readonly processTaskResolver: ProcessTaskResolver;
+ *
+ *     registerResolvers(resolvers: TaskResolverRegistry): void {
+ *         resolvers.register('process', this.processTaskResolver);
+ *         resolvers.register('shell', this.processTaskResolver);
+ *     }
+ * }
+ * ```
+ */
+export interface TaskContribution {
+    /**
+     * Register task resolvers using the given `TaskResolverRegistry`.
+     * @param resolvers the task resolver registry.
+     */
+    registerResolvers?(resolvers: TaskResolverRegistry): void;
+    /**
+     * Register task providers using the given `TaskProviderRegistry`.
+     * @param resolvers the task provider registry.
+     */
+    registerProviders?(providers: TaskProviderRegistry): void;
+}
+
+/**
+ * A {@link TaskResolver} is used to preprocess/resolve a task before sending
+ * it to the Task Server. For instance, the resolver can be used to add missing information to the configuration
+ * (e.g default values for optional parameters).
+ */
+export interface TaskResolver {
+    /**
+     * Resolves a `TaskConfiguration` before sending it for execution to the `TaskServer` (Backend).
+     * @param taskConfig the configuration that should be resolved.
+     *
+     * @returns a promise of the resolved `TaskConfiguration`.
+     */
+
+    resolveTask(taskConfig: TaskConfiguration): Promise<TaskConfiguration>;
+}
+
+/**
+ * A {@link TaskProvider} can be used to define the set of tasks that should
+ * be provided to the system. i.e. that are available for the user to run.
+ */
+export interface TaskProvider {
+    /**
+     * Retrieves the task configurations which are provided programmatically to the system.
+     *
+     * @returns a promise of the provided tasks configurations.
+     */
+    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}
+ * for each contribution.
+ */
+@injectable()
+export class TaskResolverRegistry {
+
+    protected readonly onWillProvideTaskResolverEmitter = new Emitter<WillResolveTaskProvider>();
+    /**
+     * Emit when the registry provides a registered resolver. i.e. when the {@link TaskResolverRegistry#getResolver}
+     * function is called.
+     */
+    readonly onWillProvideTaskResolver = this.onWillProvideTaskResolverEmitter.event;
+
+    protected taskResolvers: Map<string, TaskResolver> = new Map();
+    protected executionResolvers: Map<string, TaskResolver> = new Map();
+
+    /**
+     * Registers the given {@link TaskResolver} to resolve the `TaskConfiguration` of the specified type.
+     * If there is already a `TaskResolver` registered for the specified type the registration will
+     * be overwritten with the new value.
+     *
+     * @deprecated since 1.12.0 use `registerTaskResolver` instead.
+     *
+     * @param type the task configuration type for which the given resolver should be registered.
+     * @param resolver the task resolver that should be registered.
+     *
+     * @returns a `Disposable` that can be invoked to unregister the given resolver
+     */
+    register(type: string, resolver: TaskResolver): Disposable {
+        return this.registerTaskResolver(type, resolver);
+    }
+
+    /**
+     * Registers the given {@link TaskResolver} to resolve the `TaskConfiguration` of the specified type.
+     * If there is already a `TaskResolver` registered for the specified type the registration will
+     * be overwritten with the new value.
+     *
+     * @param type the task configuration type for which the given resolver should be registered.
+     * @param resolver the task resolver that should be registered.
+     *
+     * @returns a `Disposable` that can be invoked to unregister the given resolver
+     */
+
+    registerTaskResolver(type: string, resolver: TaskResolver): Disposable {
+        if (this.taskResolvers.has(type)) {
+            console.warn(`Overriding task resolver for ${type}`);
+        }
+        this.taskResolvers.set(type, resolver);
+        return {
+            dispose: () => this.taskResolvers.delete(type)
+        };
+    }
+
+    /**
+     * Retrieves the {@link TaskResolver} registered for the given type task configuration type.
+     *
+     * @deprecated since 1.12.0 use `getTaskResolver()` instead.
+     *
+     * @param type the task configuration type
+     *
+     * @returns a promise of the registered `TaskResolver` or `undefined` if no resolver is registered for the given type.
+     */
+    async getResolver(type: string): Promise<TaskResolver | undefined> {
+        return this.getTaskResolver(type);
+    }
+
+    /**
+     * Retrieves the {@link TaskResolver} registered for the given type task configuration type.
+     * @param type the task configuration type
+     *
+     * @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, { taskType: type });
+        return this.taskResolvers.get(type);
+    }
+
+    /**
+     * Registers the given {@link TaskResolver} to resolve the `TaskConfiguration` for the
+     * specified type of execution ('shell', 'process' or 'customExecution').
+     * If there is already a `TaskResolver` registered for the specified type the registration will
+     * be overwritten with the new value.
+     *
+     * @param type the task execution type for which the given resolver should be registered.
+     * @param resolver the task resolver that should be registered.
+     *
+     * @returns a `Disposable` that can be invoked to unregister the given resolver
+     */
+    registerExecutionResolver(type: string, resolver: TaskResolver): Disposable {
+        if (this.executionResolvers.has(type)) {
+            console.warn(`Overriding execution resolver for ${type}`);
+        }
+        this.executionResolvers.set(type, resolver);
+        return {
+            dispose: () => this.executionResolvers.delete(type)
+        };
+    }
+
+    /**
+     * Retrieves the {@link TaskResolver} registered for the given type of execution ('shell', 'process' or 'customExecution')..
+     * @param type the task configuration type
+     *
+     * @returns a promise of the registered `TaskResolver` or `undefined` if no resolver is registered for the given type.
+     */
+    getExecutionResolver(executionType: string): TaskResolver | undefined {
+        return this.executionResolvers.get(executionType);
+    }
+}
+
+/**
+ * The {@link TaskProviderRegistry} is the common component for registration and provision of
+ * {@link TaskProvider}s. Theia will collect all {@link TaskContribution}s and invoke {@link TaskContribution#registerProviders}
+ * for each contribution.
+ */
+@injectable()
+export class TaskProviderRegistry {
+
+    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.
+     */
+    readonly onWillProvideTaskProvider = this.onWillProvideTaskProviderEmitter.event;
+
+    protected providers: Map<string, TaskProvider>;
+
+    @postConstruct()
+    protected init(): void {
+        this.providers = new Map();
+    }
+
+    /**
+     * Registers the given {@link TaskProvider} for task configurations of the specified type
+     * @param type the task configuration type for which the given provider should be registered.
+     * @param provider the `TaskProvider` that should be registered.
+     *
+     * @returns a `Disposable` that can be invoked to unregister the given resolver.
+     */
+    register(type: string, provider: TaskProvider, handle?: number): Disposable {
+        const key = handle === undefined ? type : `${type}::${handle}`;
+        this.providers.set(key, provider);
+        return {
+            dispose: () => this.providers.delete(key)
+        };
+    }
+
+    /**
+     * 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
+     * be overwritten with the new value.
+     * @param type the task configuration type.
+     *
+     * @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 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[]> {
+        return [...this.providers.values()];
+    }
+}