@codingame/monaco-vscode-task-service-override 1.85.2

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

@@ -0,0 +1,167 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ITaskService } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskService';
+import { TASKS_CATEGORY, TaskSourceKind, RunOnOptions } from 'vscode/vscode/vs/workbench/contrib/tasks/common/tasks';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+
+const ALLOW_AUTOMATIC_TASKS = 'task.allowAutomaticTasks';
+let RunAutomaticTasks = class RunAutomaticTasks extends Disposable {
+    constructor(_taskService, _configurationService, _workspaceTrustManagementService, _logService) {
+        super();
+        this._taskService = _taskService;
+        this._configurationService = _configurationService;
+        this._workspaceTrustManagementService = _workspaceTrustManagementService;
+        this._logService = _logService;
+        this._hasRunTasks = false;
+        if (this._taskService.isReconnected) {
+            this._tryRunTasks();
+        }
+        else {
+            this._register(Event.once(this._taskService.onDidReconnectToTasks)(async () => await this._tryRunTasks()));
+        }
+        this._register(this._workspaceTrustManagementService.onDidChangeTrust(async () => await this._tryRunTasks()));
+    }
+    async _tryRunTasks() {
+        if (!this._workspaceTrustManagementService.isWorkspaceTrusted()) {
+            return;
+        }
+        if (this._hasRunTasks || this._configurationService.getValue(ALLOW_AUTOMATIC_TASKS) === 'off') {
+            return;
+        }
+        this._hasRunTasks = true;
+        this._logService.trace('RunAutomaticTasks: Trying to run tasks.');
+        if (!this._taskService.hasTaskSystemInfo) {
+            this._logService.trace('RunAutomaticTasks: Awaiting task system info.');
+            await Event.toPromise(Event.once(this._taskService.onDidChangeTaskSystemInfo));
+        }
+        const workspaceTasks = await this._taskService.getWorkspaceTasks(2 );
+        this._logService.trace(`RunAutomaticTasks: Found ${workspaceTasks.size} automatic tasks`);
+        await this._runWithPermission(this._taskService, this._configurationService, workspaceTasks);
+    }
+    _runTasks(taskService, tasks) {
+        tasks.forEach(task => {
+            if (task instanceof Promise) {
+                task.then(promiseResult => {
+                    if (promiseResult) {
+                        taskService.run(promiseResult);
+                    }
+                });
+            }
+            else {
+                taskService.run(task);
+            }
+        });
+    }
+    _getTaskSource(source) {
+        const taskKind = TaskSourceKind.toConfigurationTarget(source.kind);
+        switch (taskKind) {
+            case 6 : {
+                return resources.joinPath(source.config.workspaceFolder.uri, source.config.file);
+            }
+            case 5 : {
+                return source.config.workspace?.configuration ?? undefined;
+            }
+        }
+        return undefined;
+    }
+    _findAutoTasks(taskService, workspaceTaskResult) {
+        const tasks = ( new Array());
+        const taskNames = ( new Array());
+        const locations = ( new Map());
+        if (workspaceTaskResult) {
+            workspaceTaskResult.forEach(resultElement => {
+                if (resultElement.set) {
+                    resultElement.set.tasks.forEach(task => {
+                        if (task.runOptions.runOn === RunOnOptions.folderOpen) {
+                            tasks.push(task);
+                            taskNames.push(task._label);
+                            const location = this._getTaskSource(task._source);
+                            if (location) {
+                                locations.set(location.fsPath, location);
+                            }
+                        }
+                    });
+                }
+                if (resultElement.configurations) {
+                    for (const configuredTask of ( Object.values(resultElement.configurations.byIdentifier))) {
+                        if (configuredTask.runOptions.runOn === RunOnOptions.folderOpen) {
+                            tasks.push(( new Promise(resolve => {
+                                taskService.getTask(resultElement.workspaceFolder, configuredTask._id, true).then(task => resolve(task));
+                            })));
+                            if (configuredTask._label) {
+                                taskNames.push(configuredTask._label);
+                            }
+                            else {
+                                taskNames.push(configuredTask.configures.task);
+                            }
+                            const location = this._getTaskSource(configuredTask._source);
+                            if (location) {
+                                locations.set(location.fsPath, location);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return { tasks, taskNames, locations };
+    }
+    async _runWithPermission(taskService, configurationService, workspaceTaskResult) {
+        const { tasks, taskNames } = this._findAutoTasks(taskService, workspaceTaskResult);
+        if (taskNames.length === 0) {
+            return;
+        }
+        if (configurationService.getValue(ALLOW_AUTOMATIC_TASKS) === 'off') {
+            return;
+        }
+        this._runTasks(taskService, tasks);
+    }
+};
+RunAutomaticTasks = ( __decorate([
+    ( __param(0, ITaskService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IWorkspaceTrustManagementService)),
+    ( __param(3, ILogService))
+], RunAutomaticTasks));
+class ManageAutomaticTaskRunning extends Action2 {
+    static { this.ID = 'workbench.action.tasks.manageAutomaticRunning'; }
+    static { this.LABEL = ( nls.localizeWithPath(
+        'vs/workbench/contrib/tasks/browser/runAutomaticTasks',
+        'workbench.action.tasks.manageAutomaticRunning',
+        "Manage Automatic Tasks"
+    )); }
+    constructor() {
+        super({
+            id: ManageAutomaticTaskRunning.ID,
+            title: ManageAutomaticTaskRunning.LABEL,
+            category: TASKS_CATEGORY
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const configurationService = accessor.get(IConfigurationService);
+        const allowItem = { label: ( nls.localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/runAutomaticTasks',
+            'workbench.action.tasks.allowAutomaticTasks',
+            "Allow Automatic Tasks"
+        )) };
+        const disallowItem = { label: ( nls.localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/runAutomaticTasks',
+            'workbench.action.tasks.disallowAutomaticTasks',
+            "Disallow Automatic Tasks"
+        )) };
+        const value = await quickInputService.pick([allowItem, disallowItem], { canPickMany: false });
+        if (!value) {
+            return;
+        }
+        configurationService.updateValue(ALLOW_AUTOMATIC_TASKS, value === allowItem ? 'on' : 'off', 2 );
+    }
+}
+
+export { ManageAutomaticTaskRunning, RunAutomaticTasks };