@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/api/common/extHostTask.js

@@ -22,7 +22,7 @@ import { ErrorNoTelemetry, NotSupportedError } from '../../../base/common/errors
 import { asArray } from '../../../base/common/arrays.js';
 
 var TaskDefinitionDTO;
-(function (TaskDefinitionDTO) {
+(function(TaskDefinitionDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -39,7 +39,7 @@ var TaskDefinitionDTO;
     TaskDefinitionDTO.to = to;
 })(TaskDefinitionDTO || (TaskDefinitionDTO = {}));
 var TaskPresentationOptionsDTO;
-(function (TaskPresentationOptionsDTO) {
+(function(TaskPresentationOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -56,7 +56,7 @@ var TaskPresentationOptionsDTO;
     TaskPresentationOptionsDTO.to = to;
 })(TaskPresentationOptionsDTO || (TaskPresentationOptionsDTO = {}));
 var ProcessExecutionOptionsDTO;
-(function (ProcessExecutionOptionsDTO) {
+(function(ProcessExecutionOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -73,13 +73,12 @@ var ProcessExecutionOptionsDTO;
     ProcessExecutionOptionsDTO.to = to;
 })(ProcessExecutionOptionsDTO || (ProcessExecutionOptionsDTO = {}));
 var ProcessExecutionDTO;
-(function (ProcessExecutionDTO) {
+(function(ProcessExecutionDTO) {
     function is(value) {
         if (value) {
             const candidate = value;
             return candidate && !!candidate.process;
-        }
-        else {
+        } else {
             return false;
         }
     }
@@ -107,7 +106,7 @@ var ProcessExecutionDTO;
     ProcessExecutionDTO.to = to;
 })(ProcessExecutionDTO || (ProcessExecutionDTO = {}));
 var ShellExecutionOptionsDTO;
-(function (ShellExecutionOptionsDTO) {
+(function(ShellExecutionOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -124,13 +123,12 @@ var ShellExecutionOptionsDTO;
     ShellExecutionOptionsDTO.to = to;
 })(ShellExecutionOptionsDTO || (ShellExecutionOptionsDTO = {}));
 var ShellExecutionDTO;
-(function (ShellExecutionDTO) {
+(function(ShellExecutionDTO) {
     function is(value) {
         if (value) {
             const candidate = value;
             return candidate && (!!candidate.commandLine || !!candidate.command);
-        }
-        else {
+        } else {
             return false;
         }
     }
@@ -142,8 +140,7 @@ var ShellExecutionDTO;
         const result = {};
         if (value.commandLine !== undefined) {
             result.commandLine = value.commandLine;
-        }
-        else {
+        } else {
             result.command = value.command;
             result.args = value.args;
         }
@@ -159,28 +156,26 @@ var ShellExecutionDTO;
         }
         if (value.commandLine) {
             return new ShellExecution(value.commandLine, value.options);
-        }
-        else {
+        } else {
             return new ShellExecution(value.command, value.args ? value.args : [], value.options);
         }
     }
     ShellExecutionDTO.to = to;
 })(ShellExecutionDTO || (ShellExecutionDTO = {}));
 var CustomExecutionDTO;
-(function (CustomExecutionDTO) {
+(function(CustomExecutionDTO) {
     function is(value) {
         if (value) {
             const candidate = value;
-            return candidate && candidate.customExecution === 'customExecution';
-        }
-        else {
+            return candidate && candidate.customExecution === "customExecution";
+        } else {
             return false;
         }
     }
     CustomExecutionDTO.is = is;
     function from(value) {
         return {
-            customExecution: 'customExecution'
+            customExecution: "customExecution"
         };
     }
     CustomExecutionDTO.from = from;
@@ -190,17 +185,15 @@ var CustomExecutionDTO;
     CustomExecutionDTO.to = to;
 })(CustomExecutionDTO || (CustomExecutionDTO = {}));
 var TaskHandleDTO;
-(function (TaskHandleDTO) {
+(function(TaskHandleDTO) {
     function from(value, workspaceService) {
         let folder;
-        if (value.scope !== undefined && typeof value.scope !== 'number') {
+        if (value.scope !== undefined && typeof value.scope !== "number") {
             folder = value.scope.uri;
-        }
-        else if (value.scope !== undefined && typeof value.scope === 'number') {
+        } else if (value.scope !== undefined && typeof value.scope === "number") {
             if ((value.scope === TaskScope.Workspace) && workspaceService && workspaceService.workspaceFile) {
                 folder = workspaceService.workspaceFile;
-            }
-            else {
+            } else {
                 folder = USER_TASKS_GROUP_KEY;
             }
         }
@@ -212,17 +205,20 @@ var TaskHandleDTO;
     TaskHandleDTO.from = from;
 })(TaskHandleDTO || (TaskHandleDTO = {}));
 var TaskGroupDTO;
-(function (TaskGroupDTO) {
+(function(TaskGroupDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
         }
-        return { _id: value.id, isDefault: value.isDefault };
+        return {
+            _id: value.id,
+            isDefault: value.isDefault
+        };
     }
     TaskGroupDTO.from = from;
 })(TaskGroupDTO || (TaskGroupDTO = {}));
 var TaskDTO;
-(function (TaskDTO) {
+(function(TaskDTO) {
     function fromMany(tasks, extension) {
         if (tasks === undefined || tasks === null) {
             return [];
@@ -244,24 +240,20 @@ var TaskDTO;
         let execution;
         if (value.execution instanceof ProcessExecution) {
             execution = ProcessExecutionDTO.from(value.execution);
-        }
-        else if (value.execution instanceof ShellExecution) {
+        } else if (value.execution instanceof ShellExecution) {
             execution = ShellExecutionDTO.from(value.execution);
-        }
-        else if (value.execution && value.execution instanceof CustomExecution) {
+        } else if (value.execution && value.execution instanceof CustomExecution) {
             execution = CustomExecutionDTO.from(value.execution);
         }
         const definition = TaskDefinitionDTO.from(value.definition);
         let scope;
         if (value.scope) {
-            if (typeof value.scope === 'number') {
+            if (typeof value.scope === "number") {
                 scope = value.scope;
-            }
-            else {
+            } else {
                 scope = value.scope.uri;
             }
-        }
-        else {
+        } else {
             scope = TaskScope.Workspace;
         }
         if (!definition || !scope) {
@@ -282,7 +274,9 @@ var TaskDTO;
             presentationOptions: TaskPresentationOptionsDTO.from(value.presentationOptions),
             problemMatchers: asArray(value.problemMatchers),
             hasDefinedMatchers: value.hasDefinedMatchers,
-            runOptions: value.runOptions ? value.runOptions : { reevaluateOnRerun: true },
+            runOptions: value.runOptions ? value.runOptions : {
+                reevaluateOnRerun: true
+            },
             detail: value.detail
         };
         return result;
@@ -295,32 +289,35 @@ var TaskDTO;
         let execution;
         if (ProcessExecutionDTO.is(value.execution)) {
             execution = ProcessExecutionDTO.to(value.execution);
-        }
-        else if (ShellExecutionDTO.is(value.execution)) {
+        } else if (ShellExecutionDTO.is(value.execution)) {
             execution = ShellExecutionDTO.to(value.execution);
-        }
-        else if (CustomExecutionDTO.is(value.execution)) {
+        } else if (CustomExecutionDTO.is(value.execution)) {
             execution = CustomExecutionDTO.to(value._id, providedCustomExeutions);
         }
         const definition = TaskDefinitionDTO.to(value.definition);
         let scope;
         if (value.source) {
             if (value.source.scope !== undefined) {
-                if (typeof value.source.scope === 'number') {
+                if (typeof value.source.scope === "number") {
                     scope = value.source.scope;
-                }
-                else {
+                } else {
                     scope = await workspace.resolveWorkspaceFolder(URI.revive(value.source.scope));
                 }
-            }
-            else {
+            } else {
                 scope = TaskScope.Workspace;
             }
         }
         if (!definition || !scope) {
             return undefined;
         }
-        const result = new Task(definition, scope, value.name, value.source.label, execution, value.problemMatchers);
+        const result = new Task(
+            definition,
+            scope,
+            value.name,
+            value.source.label,
+            execution,
+            value.problemMatchers
+        );
         if (value.isBackground !== undefined) {
             result.isBackground = value.isBackground;
         }
@@ -347,7 +344,7 @@ var TaskDTO;
     TaskDTO.to = to;
 })(TaskDTO || (TaskDTO = {}));
 var TaskFilterDTO;
-(function (TaskFilterDTO) {
+(function(TaskFilterDTO) {
     function from(value) {
         return value;
     }
@@ -373,10 +370,8 @@ class TaskExecutionImpl {
     terminate() {
         this.#tasks.terminateTask(this);
     }
-    fireDidStartProcess(value) {
-    }
-    fireDidEndProcess(value) {
-    }
+    fireDidStartProcess(value) {}
+    fireDidEndProcess(value) {}
     get terminal() {
         return this._terminal;
     }
@@ -385,7 +380,16 @@ class TaskExecutionImpl {
     }
 }
 let ExtHostTaskBase = class ExtHostTaskBase {
-    constructor(extHostRpc, initData, workspaceService, editorService, configurationService, extHostTerminalService, logService, deprecationService) {
+    constructor(
+        extHostRpc,
+        initData,
+        workspaceService,
+        editorService,
+        configurationService,
+        extHostTerminalService,
+        logService,
+        deprecationService
+    ) {
         this._onDidExecuteTask = ( new Emitter());
         this._onDidTerminateTask = ( new Emitter());
         this._onDidTaskProcessStarted = ( new Emitter());
@@ -410,10 +414,14 @@ let ExtHostTaskBase = class ExtHostTaskBase {
     }
     registerTaskProvider(extension, type, provider) {
         if (!provider) {
-            return new Disposable(() => { });
+            return new Disposable(() => {});
         }
         const handle = this.nextHandle();
-        this._handlers.set(handle, { type, provider, extension });
+        this._handlers.set(handle, {
+            type,
+            provider,
+            extension
+        });
         this._proxy.$registerTaskProvider(handle, type);
         return new Disposable(() => {
             this._handlers.delete(handle);
@@ -424,7 +432,7 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         this._proxy.$registerTaskSystem(scheme, info);
     }
     fetchTasks(filter) {
-        return this._proxy.$fetchTasks(TaskFilterDTO.from(filter)).then(async (values) => {
+        return this._proxy.$fetchTasks(TaskFilterDTO.from(filter)).then(async values => {
             const result = [];
             for (const value of values) {
                 const task = await TaskDTO.to(value, this._workspaceProvider, this._providedCustomExecutions2);
@@ -442,7 +450,7 @@ let ExtHostTaskBase = class ExtHostTaskBase {
     }
     terminateTask(execution) {
         if (!(execution instanceof TaskExecutionImpl)) {
-            throw ( new Error('No valid task execution provided'));
+            throw ( new Error("No valid task execution provided"));
         }
         return this._proxy.$terminateTask(execution._id);
     }
@@ -507,11 +515,12 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         let execution;
         try {
             execution = await this.getTaskExecution(value.execution.id);
-        }
-        catch (error) {
+        } catch (error) {
             return;
         }
-        this._onDidStartTaskProblemMatchers.fire({ execution });
+        this._onDidStartTaskProblemMatchers.fire({
+            execution
+        });
     }
     get onDidEndTaskProblemMatchers() {
         return this._onDidEndTaskProblemMatchers.event;
@@ -520,23 +529,25 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         let execution;
         try {
             execution = await this.getTaskExecution(value.execution.id);
-        }
-        catch (error) {
+        } catch (error) {
             return;
         }
-        this._onDidEndTaskProblemMatchers.fire({ execution, hasErrors: value.hasErrors });
+        this._onDidEndTaskProblemMatchers.fire({
+            execution,
+            hasErrors: value.hasErrors
+        });
     }
     $provideTasks(handle, validTypes) {
         const handler = this._handlers.get(handle);
         if (!handler) {
-            return Promise.reject(( new Error('no handler found')));
+            return Promise.reject(( new Error("no handler found")));
         }
         const taskIdPromises = [];
         const fetchPromise = asPromise(() => handler.provider.provideTasks(CancellationToken.None)).then(value => {
             return this.provideTasksInternal(validTypes, taskIdPromises, handler, value);
         });
-        return ( new Promise((resolve) => {
-            fetchPromise.then((result) => {
+        return ( new Promise(resolve => {
+            fetchPromise.then(result => {
                 Promise.all(taskIdPromises).then(() => {
                     resolve(result);
                 });
@@ -546,7 +557,7 @@ let ExtHostTaskBase = class ExtHostTaskBase {
     async $resolveTask(handle, taskDTO) {
         const handler = this._handlers.get(handle);
         if (!handler) {
-            return Promise.reject(( new Error('no handler found')));
+            return Promise.reject(( new Error("no handler found")));
         }
         if (taskDTO.definition.type !== handler.type) {
             throw ( new Error(
@@ -555,7 +566,7 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         }
         const task = await TaskDTO.to(taskDTO, this._workspaceProvider, this._providedCustomExecutions2);
         if (!task) {
-            throw ( new Error('Unexpected: Task cannot be resolved.'));
+            throw ( new Error("Unexpected: Task cannot be resolved."));
         }
         const resolvedTask = await handler.provider.resolveTask(task, CancellationToken.None);
         if (!resolvedTask) {
@@ -564,11 +575,11 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         this.checkDeprecation(resolvedTask, handler);
         const resolvedTaskDTO = TaskDTO.from(resolvedTask, handler.extension);
         if (!resolvedTaskDTO) {
-            throw ( new Error('Unexpected: Task cannot be resolved.'));
+            throw ( new Error("Unexpected: Task cannot be resolved."));
         }
         if (resolvedTask.definition !== task.definition) {
             throw ( new Error(
-                'Unexpected: The resolved task definition must be the same object as the original task definition. The task definition cannot be changed.'
+                "Unexpected: The resolved task definition must be the same object as the original task definition. The task definition cannot be changed."
             ));
         }
         if (CustomExecutionDTO.is(resolvedTaskDTO.execution)) {
@@ -588,10 +599,10 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         this._providedCustomExecutions2.set(taskId, task.execution);
     }
     async getTaskExecution(execution, task) {
-        if (typeof execution === 'string') {
+        if (typeof execution === "string") {
             const taskExecution = this._taskExecutionPromises.get(execution);
             if (!taskExecution) {
-                throw ( new ErrorNoTelemetry('Unexpected: The specified task is missing an execution'));
+                throw ( new ErrorNoTelemetry("Unexpected: The specified task is missing an execution"));
             }
             return taskExecution;
         }
@@ -603,12 +614,11 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         if (!task) {
             executionPromise = TaskDTO.to(execution.task, this._workspaceProvider, this._providedCustomExecutions2).then(t => {
                 if (!t) {
-                    throw ( new ErrorNoTelemetry('Unexpected: Task does not exist.'));
+                    throw ( new ErrorNoTelemetry("Unexpected: Task does not exist."));
                 }
                 return ( new TaskExecutionImpl(this, execution.id, t));
             });
-        }
-        else {
+        } else {
             executionPromise = Promise.resolve(( new TaskExecutionImpl(this, execution.id, task)));
         }
         this._taskExecutionPromises.set(execution.id, executionPromise);
@@ -620,7 +630,11 @@ let ExtHostTaskBase = class ExtHostTaskBase {
     checkDeprecation(task, handler) {
         const tTask = task;
         if (tTask._deprecated) {
-            this._deprecationService.report('Task.constructor', handler.extension, 'Use the Task constructor that takes a `scope` instead.');
+            this._deprecationService.report(
+                "Task.constructor",
+                handler.extension,
+                "Use the Task constructor that takes a `scope` instead."
+            );
         }
     }
     customExecutionComplete(execution) {
@@ -643,41 +657,51 @@ let ExtHostTaskBase = class ExtHostTaskBase {
         }
     }
 };
-ExtHostTaskBase = ( __decorate([
-    ( __param(0, IExtHostRpcService)),
-    ( __param(1, IExtHostInitDataService)),
-    ( __param(2, IExtHostWorkspace)),
-    ( __param(3, IExtHostDocumentsAndEditors)),
-    ( __param(4, IExtHostConfiguration)),
-    ( __param(5, IExtHostTerminalService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IExtHostApiDeprecationService))
-], ExtHostTaskBase));
+ExtHostTaskBase = ( __decorate([( __param(0, IExtHostRpcService)), ( __param(1, IExtHostInitDataService)), ( __param(2, IExtHostWorkspace)), ( __param(3, IExtHostDocumentsAndEditors)), ( __param(4, IExtHostConfiguration)), ( __param(5, IExtHostTerminalService)), ( __param(6, ILogService)), ( __param(7, IExtHostApiDeprecationService))], ExtHostTaskBase));
 let WorkerExtHostTask = class WorkerExtHostTask extends ExtHostTaskBase {
-    constructor(extHostRpc, initData, workspaceService, editorService, configurationService, extHostTerminalService, logService, deprecationService) {
-        super(extHostRpc, initData, workspaceService, editorService, configurationService, extHostTerminalService, logService, deprecationService);
+    constructor(
+        extHostRpc,
+        initData,
+        workspaceService,
+        editorService,
+        configurationService,
+        extHostTerminalService,
+        logService,
+        deprecationService
+    ) {
+        super(
+            extHostRpc,
+            initData,
+            workspaceService,
+            editorService,
+            configurationService,
+            extHostTerminalService,
+            logService,
+            deprecationService
+        );
         this.registerTaskSystem(Schemas.vscodeRemote, {
             scheme: Schemas.vscodeRemote,
-            authority: '',
+            authority: "",
             platform: PlatformToString(Platform.Web)
         });
     }
     async executeTask(extension, task) {
         if (!task.execution) {
-            throw ( new Error('Tasks to execute must include an execution'));
+            throw ( new Error("Tasks to execute must include an execution"));
         }
         const dto = TaskDTO.from(task, extension);
         if (dto === undefined) {
-            throw ( new Error('Task is not valid'));
+            throw ( new Error("Task is not valid"));
         }
         if (CustomExecutionDTO.is(dto.execution)) {
             await this.addCustomExecution(dto, task, false);
-        }
-        else {
+        } else {
             throw ( new NotSupportedError());
         }
         const execution = await this.getTaskExecution(await this._proxy.$getTaskExecution(dto), task);
-        this._proxy.$executeTask(dto).catch(error => { throw ( new Error(error)); });
+        this._proxy.$executeTask(dto).catch(error => {
+            throw ( new Error(error));
+        });
         return execution;
     }
     provideTasksInternal(validTypes, taskIdPromises, handler, value) {
@@ -686,16 +710,17 @@ let WorkerExtHostTask = class WorkerExtHostTask extends ExtHostTaskBase {
             for (const task of value) {
                 this.checkDeprecation(task, handler);
                 if (!task.definition || !validTypes[task.definition.type]) {
-                    const source = task.source ? task.source : 'No task source';
-                    this._logService.warn(`The task [${source}, ${task.name}] uses an undefined task type. The task will be ignored in the future.`);
+                    const source = task.source ? task.source : "No task source";
+                    this._logService.warn(
+                        `The task [${source}, ${task.name}] uses an undefined task type. The task will be ignored in the future.`
+                    );
                 }
                 const taskDTO = TaskDTO.from(task, handler.extension);
                 if (taskDTO && CustomExecutionDTO.is(taskDTO.execution)) {
                     taskDTOs.push(taskDTO);
                     taskIdPromises.push(this.addCustomExecution(taskDTO, task, true));
-                }
-                else {
-                    this._logService.warn('Only custom execution tasks supported.');
+                } else {
+                    this._logService.warn("Only custom execution tasks supported.");
                 }
             }
         }
@@ -707,9 +732,8 @@ let WorkerExtHostTask = class WorkerExtHostTask extends ExtHostTaskBase {
     async resolveTaskInternal(resolvedTaskDTO) {
         if (CustomExecutionDTO.is(resolvedTaskDTO.execution)) {
             return resolvedTaskDTO;
-        }
-        else {
-            this._logService.warn('Only custom execution tasks supported.');
+        } else {
+            this._logService.warn("Only custom execution tasks supported.");
         }
         return undefined;
     }
@@ -727,16 +751,7 @@ let WorkerExtHostTask = class WorkerExtHostTask extends ExtHostTaskBase {
         return undefined;
     }
 };
-WorkerExtHostTask = ( __decorate([
-    ( __param(0, IExtHostRpcService)),
-    ( __param(1, IExtHostInitDataService)),
-    ( __param(2, IExtHostWorkspace)),
-    ( __param(3, IExtHostDocumentsAndEditors)),
-    ( __param(4, IExtHostConfiguration)),
-    ( __param(5, IExtHostTerminalService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IExtHostApiDeprecationService))
-], WorkerExtHostTask));
-const IExtHostTask = ( createDecorator('IExtHostTask'));
+WorkerExtHostTask = ( __decorate([( __param(0, IExtHostRpcService)), ( __param(1, IExtHostInitDataService)), ( __param(2, IExtHostWorkspace)), ( __param(3, IExtHostDocumentsAndEditors)), ( __param(4, IExtHostConfiguration)), ( __param(5, IExtHostTerminalService)), ( __param(6, ILogService)), ( __param(7, IExtHostApiDeprecationService))], WorkerExtHostTask));
+const IExtHostTask = ( createDecorator("IExtHostTask"));
 
 export { CustomExecutionDTO, ExtHostTaskBase, IExtHostTask, TaskDTO, TaskHandleDTO, WorkerExtHostTask };