@theia/task 1.45.1 → 1.46.0-next.72

package/lib/browser/task-contribution.js

@@ -1,207 +1,207 @@
-"use strict";
-// *****************************************************************************
-// 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
-// *****************************************************************************
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskProviderRegistry = exports.TaskResolverRegistry = exports.TaskContribution = void 0;
-const inversify_1 = require("@theia/core/shared/inversify");
-const event_1 = require("@theia/core/lib/common/event");
-exports.TaskContribution = Symbol('TaskContribution');
-/**
- * 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.
- */
-let TaskResolverRegistry = class TaskResolverRegistry {
-    constructor() {
-        this.onWillProvideTaskResolverEmitter = new event_1.Emitter();
-        /**
-         * Emit when the registry provides a registered resolver. i.e. when the {@link TaskResolverRegistry#getResolver}
-         * function is called.
-         */
-        this.onWillProvideTaskResolver = this.onWillProvideTaskResolverEmitter.event;
-        this.taskResolvers = new Map();
-        this.executionResolvers = 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, resolver) {
-        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, resolver) {
-        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) {
-        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) {
-        await event_1.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, resolver) {
-        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) {
-        return this.executionResolvers.get(executionType);
-    }
-};
-TaskResolverRegistry = __decorate([
-    (0, inversify_1.injectable)()
-], TaskResolverRegistry);
-exports.TaskResolverRegistry = TaskResolverRegistry;
-/**
- * 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.
- */
-let TaskProviderRegistry = class TaskProviderRegistry {
-    constructor() {
-        this.onWillProvideTaskProviderEmitter = new event_1.Emitter();
-        /**
-         * Emit when the registry provides a registered task provider. i.e. when the {@link TaskProviderRegistry#getProvider}
-         * function is called.
-         */
-        this.onWillProvideTaskProvider = this.onWillProvideTaskProviderEmitter.event;
-    }
-    init() {
-        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, provider, handle) {
-        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) {
-        await event_1.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) {
-        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() {
-        return [...this.providers.values()];
-    }
-};
-__decorate([
-    (0, inversify_1.postConstruct)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], TaskProviderRegistry.prototype, "init", null);
-TaskProviderRegistry = __decorate([
-    (0, inversify_1.injectable)()
-], TaskProviderRegistry);
-exports.TaskProviderRegistry = TaskProviderRegistry;
+"use strict";
+// *****************************************************************************
+// 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
+// *****************************************************************************
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProviderRegistry = exports.TaskResolverRegistry = exports.TaskContribution = void 0;
+const inversify_1 = require("@theia/core/shared/inversify");
+const event_1 = require("@theia/core/lib/common/event");
+exports.TaskContribution = Symbol('TaskContribution');
+/**
+ * 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.
+ */
+let TaskResolverRegistry = class TaskResolverRegistry {
+    constructor() {
+        this.onWillProvideTaskResolverEmitter = new event_1.Emitter();
+        /**
+         * Emit when the registry provides a registered resolver. i.e. when the {@link TaskResolverRegistry#getResolver}
+         * function is called.
+         */
+        this.onWillProvideTaskResolver = this.onWillProvideTaskResolverEmitter.event;
+        this.taskResolvers = new Map();
+        this.executionResolvers = 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, resolver) {
+        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, resolver) {
+        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) {
+        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) {
+        await event_1.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, resolver) {
+        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) {
+        return this.executionResolvers.get(executionType);
+    }
+};
+TaskResolverRegistry = __decorate([
+    (0, inversify_1.injectable)()
+], TaskResolverRegistry);
+exports.TaskResolverRegistry = TaskResolverRegistry;
+/**
+ * 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.
+ */
+let TaskProviderRegistry = class TaskProviderRegistry {
+    constructor() {
+        this.onWillProvideTaskProviderEmitter = new event_1.Emitter();
+        /**
+         * Emit when the registry provides a registered task provider. i.e. when the {@link TaskProviderRegistry#getProvider}
+         * function is called.
+         */
+        this.onWillProvideTaskProvider = this.onWillProvideTaskProviderEmitter.event;
+    }
+    init() {
+        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, provider, handle) {
+        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) {
+        await event_1.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) {
+        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() {
+        return [...this.providers.values()];
+    }
+};
+__decorate([
+    (0, inversify_1.postConstruct)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TaskProviderRegistry.prototype, "init", null);
+TaskProviderRegistry = __decorate([
+    (0, inversify_1.injectable)()
+], TaskProviderRegistry);
+exports.TaskProviderRegistry = TaskProviderRegistry;
 //# sourceMappingURL=task-contribution.js.map

package/lib/browser/task-definition-registry.d.ts

@@ -1,39 +1,39 @@
-import { Event, Emitter } from '@theia/core/lib/common';
-import { TaskConfiguration, TaskDefinition, TaskCustomization } from '../common';
-import { Disposable } from '@theia/core/lib/common/disposable';
-export declare class TaskDefinitionRegistry {
-    private definitions;
-    protected readonly onDidRegisterTaskDefinitionEmitter: Emitter<void>;
-    get onDidRegisterTaskDefinition(): Event<void>;
-    protected readonly onDidUnregisterTaskDefinitionEmitter: Emitter<void>;
-    get onDidUnregisterTaskDefinition(): Event<void>;
-    /**
-     * Returns all task definitions that are registered
-     * @return the task definitions that are registered
-     */
-    getAll(): TaskDefinition[];
-    /**
-     * Finds the task definition(s) from the registry with the given `taskType`.
-     *
-     * @param taskType the type of the task
-     * @return an array of the task definitions. If no task definitions are found, an empty array is returned.
-     */
-    getDefinitions(taskType: string): TaskDefinition[];
-    /**
-     * Finds the task definition from the registry for the task configuration.
-     * The task configuration is considered as a "match" to the task definition if it has all the `required` properties.
-     * In case that more than one task definition is found, return the one that has the biggest number of matched properties.
-     *
-     * @param taskConfiguration the task configuration
-     * @return the task definition for the task configuration. If the task definition is not found, `undefined` is returned.
-     */
-    getDefinition(taskConfiguration: TaskConfiguration | TaskCustomization): TaskDefinition | undefined;
-    /**
-     * Add a task definition to the registry.
-     *
-     * @param definition the task definition to be added.
-     */
-    register(definition: TaskDefinition): Disposable;
-    compareTasks(one: TaskConfiguration | TaskCustomization, other: TaskConfiguration | TaskCustomization): boolean;
-}
+import { Event, Emitter } from '@theia/core/lib/common';
+import { TaskConfiguration, TaskDefinition, TaskCustomization } from '../common';
+import { Disposable } from '@theia/core/lib/common/disposable';
+export declare class TaskDefinitionRegistry {
+    private definitions;
+    protected readonly onDidRegisterTaskDefinitionEmitter: Emitter<void>;
+    get onDidRegisterTaskDefinition(): Event<void>;
+    protected readonly onDidUnregisterTaskDefinitionEmitter: Emitter<void>;
+    get onDidUnregisterTaskDefinition(): Event<void>;
+    /**
+     * Returns all task definitions that are registered
+     * @return the task definitions that are registered
+     */
+    getAll(): TaskDefinition[];
+    /**
+     * Finds the task definition(s) from the registry with the given `taskType`.
+     *
+     * @param taskType the type of the task
+     * @return an array of the task definitions. If no task definitions are found, an empty array is returned.
+     */
+    getDefinitions(taskType: string): TaskDefinition[];
+    /**
+     * Finds the task definition from the registry for the task configuration.
+     * The task configuration is considered as a "match" to the task definition if it has all the `required` properties.
+     * In case that more than one task definition is found, return the one that has the biggest number of matched properties.
+     *
+     * @param taskConfiguration the task configuration
+     * @return the task definition for the task configuration. If the task definition is not found, `undefined` is returned.
+     */
+    getDefinition(taskConfiguration: TaskConfiguration | TaskCustomization): TaskDefinition | undefined;
+    /**
+     * Add a task definition to the registry.
+     *
+     * @param definition the task definition to be added.
+     */
+    register(definition: TaskDefinition): Disposable;
+    compareTasks(one: TaskConfiguration | TaskCustomization, other: TaskConfiguration | TaskCustomization): boolean;
+}
 //# sourceMappingURL=task-definition-registry.d.ts.map