@codingame/monaco-vscode-extensions-service-override 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/api/browser/mainThreadTask.js

@@ -12,8 +12,9 @@ import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/comm
 import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
 
+const _moduleId = "vs/workbench/api/browser/mainThreadTask";
 var TaskExecutionDTO;
-( (function(TaskExecutionDTO) {
+( ((function(TaskExecutionDTO) {
     function from(value) {
         return {
             id: value.id,
@@ -21,9 +22,9 @@ var TaskExecutionDTO;
         };
     }
     TaskExecutionDTO.from = from;
-})(TaskExecutionDTO || (TaskExecutionDTO = {})));
+})(TaskExecutionDTO || (TaskExecutionDTO = {}))));
 var TaskProcessStartedDTO;
-( (function(TaskProcessStartedDTO) {
+( ((function(TaskProcessStartedDTO) {
     function from(value, processId) {
         return {
             id: value.id,
@@ -31,9 +32,9 @@ var TaskProcessStartedDTO;
         };
     }
     TaskProcessStartedDTO.from = from;
-})(TaskProcessStartedDTO || (TaskProcessStartedDTO = {})));
+})(TaskProcessStartedDTO || (TaskProcessStartedDTO = {}))));
 var TaskProcessEndedDTO;
-( (function(TaskProcessEndedDTO) {
+( ((function(TaskProcessEndedDTO) {
     function from(value, exitCode) {
         return {
             id: value.id,
@@ -41,9 +42,9 @@ var TaskProcessEndedDTO;
         };
     }
     TaskProcessEndedDTO.from = from;
-})(TaskProcessEndedDTO || (TaskProcessEndedDTO = {})));
+})(TaskProcessEndedDTO || (TaskProcessEndedDTO = {}))));
 var TaskDefinitionDTO;
-( (function(TaskDefinitionDTO) {
+( ((function(TaskDefinitionDTO) {
     function from(value) {
         const result = Object.assign(Object.create(null), value);
         delete result._key;
@@ -61,9 +62,9 @@ var TaskDefinitionDTO;
         return result;
     }
     TaskDefinitionDTO.to = to;
-})(TaskDefinitionDTO || (TaskDefinitionDTO = {})));
+})(TaskDefinitionDTO || (TaskDefinitionDTO = {}))));
 var TaskPresentationOptionsDTO;
-( (function(TaskPresentationOptionsDTO) {
+( ((function(TaskPresentationOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -78,9 +79,9 @@ var TaskPresentationOptionsDTO;
         return Object.assign(Object.create(null), PresentationOptions.defaults, value);
     }
     TaskPresentationOptionsDTO.to = to;
-})(TaskPresentationOptionsDTO || (TaskPresentationOptionsDTO = {})));
+})(TaskPresentationOptionsDTO || (TaskPresentationOptionsDTO = {}))));
 var RunOptionsDTO;
-( (function(RunOptionsDTO) {
+( ((function(RunOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -95,9 +96,9 @@ var RunOptionsDTO;
         return Object.assign(Object.create(null), RunOptions.defaults, value);
     }
     RunOptionsDTO.to = to;
-})(RunOptionsDTO || (RunOptionsDTO = {})));
+})(RunOptionsDTO || (RunOptionsDTO = {}))));
 var ProcessExecutionOptionsDTO;
-( (function(ProcessExecutionOptionsDTO) {
+( ((function(ProcessExecutionOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -118,9 +119,9 @@ var ProcessExecutionOptionsDTO;
         };
     }
     ProcessExecutionOptionsDTO.to = to;
-})(ProcessExecutionOptionsDTO || (ProcessExecutionOptionsDTO = {})));
+})(ProcessExecutionOptionsDTO || (ProcessExecutionOptionsDTO = {}))));
 var ProcessExecutionDTO;
-( (function(ProcessExecutionDTO) {
+( ((function(ProcessExecutionDTO) {
     function is(value) {
         const candidate = value;
         return candidate && !!candidate.process;
@@ -128,7 +129,7 @@ var ProcessExecutionDTO;
     ProcessExecutionDTO.is = is;
     function from(value) {
         const process = isString(value.name) ? value.name : value.name.value;
-        const args = value.args ? ( value.args.map(value => isString(value) ? value : value.value)) : [];
+        const args = value.args ? ( (value.args.map(value => isString(value) ? value : value.value))) : [];
         const result = {
             process: process,
             args: args
@@ -150,9 +151,9 @@ var ProcessExecutionDTO;
         return result;
     }
     ProcessExecutionDTO.to = to;
-})(ProcessExecutionDTO || (ProcessExecutionDTO = {})));
+})(ProcessExecutionDTO || (ProcessExecutionDTO = {}))));
 var ShellExecutionOptionsDTO;
-( (function(ShellExecutionOptionsDTO) {
+( ((function(ShellExecutionOptionsDTO) {
     function from(value) {
         if (value === undefined || value === null) {
             return undefined;
@@ -191,9 +192,9 @@ var ShellExecutionOptionsDTO;
         return result;
     }
     ShellExecutionOptionsDTO.to = to;
-})(ShellExecutionOptionsDTO || (ShellExecutionOptionsDTO = {})));
+})(ShellExecutionOptionsDTO || (ShellExecutionOptionsDTO = {}))));
 var ShellExecutionDTO;
-( (function(ShellExecutionDTO) {
+( ((function(ShellExecutionDTO) {
     function is(value) {
         const candidate = value;
         return candidate && (!!candidate.commandLine || !!candidate.command);
@@ -227,9 +228,9 @@ var ShellExecutionDTO;
         return result;
     }
     ShellExecutionDTO.to = to;
-})(ShellExecutionDTO || (ShellExecutionDTO = {})));
+})(ShellExecutionDTO || (ShellExecutionDTO = {}))));
 var CustomExecutionDTO;
-( (function(CustomExecutionDTO) {
+( ((function(CustomExecutionDTO) {
     function is(value) {
         const candidate = value;
         return candidate && candidate.customExecution === 'customExecution';
@@ -248,9 +249,9 @@ var CustomExecutionDTO;
         };
     }
     CustomExecutionDTO.to = to;
-})(CustomExecutionDTO || (CustomExecutionDTO = {})));
+})(CustomExecutionDTO || (CustomExecutionDTO = {}))));
 var TaskSourceDTO;
-( (function(TaskSourceDTO) {
+( ((function(TaskSourceDTO) {
     function from(value) {
         const result = {
             label: value.label
@@ -301,17 +302,17 @@ var TaskSourceDTO;
         return result;
     }
     TaskSourceDTO.to = to;
-})(TaskSourceDTO || (TaskSourceDTO = {})));
+})(TaskSourceDTO || (TaskSourceDTO = {}))));
 var TaskHandleDTO;
-( (function(TaskHandleDTO) {
+( ((function(TaskHandleDTO) {
     function is(value) {
         const candidate = value;
         return candidate && isString(candidate.id) && !!candidate.workspaceFolder;
     }
     TaskHandleDTO.is = is;
-})(TaskHandleDTO || (TaskHandleDTO = {})));
+})(TaskHandleDTO || (TaskHandleDTO = {}))));
 var TaskDTO;
-( (function(TaskDTO) {
+( ((function(TaskDTO) {
     function from(task) {
         if (task === undefined || task === null || (!CustomTask.is(task) && !ContributedTask.is(task) && !ConfiguringTask.is(task))) {
             return undefined;
@@ -376,32 +377,36 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadTask',
-            'task.label',
-            '{0}: {1}',
-            source.label,
-            task.name
-        ));
+        const label = ( localizeWithPath(_moduleId, 0, '{0}: {1}', source.label, task.name));
         const definition = TaskDefinitionDTO.to(task.definition, executeOnly);
         const id = (CustomExecutionDTO.is(task.execution) && task._id) ? task._id : `${task.source.extensionId}.${definition._key}`;
-        const result = ( new ContributedTask(
-        id, source, label, definition.type, definition, command, task.hasDefinedMatchers, RunOptionsDTO.to(task.runOptions), {
-            name: task.name,
-            identifier: label,
-            group: task.group,
-            isBackground: !!task.isBackground,
-            problemMatchers: task.problemMatchers.slice(),
-            detail: task.detail,
-            icon,
-            hide
-        }));
+        const result = ( (new
+        ContributedTask(
+            id,
+            source,
+            label,
+            definition.type,
+            definition,
+            command,
+            task.hasDefinedMatchers,
+            RunOptionsDTO.to(task.runOptions),
+            {
+                name: task.name,
+                identifier: label,
+                group: task.group,
+                isBackground: !!task.isBackground,
+                problemMatchers: task.problemMatchers.slice(),
+                detail: task.detail,
+                icon,
+                hide
+            }
+        )));
         return result;
     }
     TaskDTO.to = to;
-})(TaskDTO || (TaskDTO = {})));
+})(TaskDTO || (TaskDTO = {}))));
 var TaskGroupDTO;
-( (function(TaskGroupDTO) {
+( ((function(TaskGroupDTO) {
     function from(value) {
         if (value === undefined) {
             return undefined;
@@ -412,9 +417,9 @@ var TaskGroupDTO;
         };
     }
     TaskGroupDTO.from = from;
-})(TaskGroupDTO || (TaskGroupDTO = {})));
+})(TaskGroupDTO || (TaskGroupDTO = {}))));
 var TaskFilterDTO;
-( (function(TaskFilterDTO) {
+( ((function(TaskFilterDTO) {
     function from(value) {
         return value;
     }
@@ -423,14 +428,14 @@ var TaskFilterDTO;
         return value;
     }
     TaskFilterDTO.to = to;
-})(TaskFilterDTO || (TaskFilterDTO = {})));
+})(TaskFilterDTO || (TaskFilterDTO = {}))));
 let MainThreadTask = class MainThreadTask {
     constructor(extHostContext, _taskService, _workspaceContextServer, _configurationResolverService) {
         this._taskService = _taskService;
         this._workspaceContextServer = _workspaceContextServer;
         this._configurationResolverService = _configurationResolverService;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTask));
-        this._providers = ( new Map());
+        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostTask)));
+        this._providers = ( (new Map()));
         this._taskService.onDidStateChange(async (event) => {
             if (event.kind === "changed" ) {
                 return;
@@ -460,21 +465,23 @@ let MainThreadTask = class MainThreadTask {
         });
     }
     dispose() {
-        for (const value of ( this._providers.values())) {
+        for (const value of ( (this._providers.values()))) {
             value.disposable.dispose();
         }
         this._providers.clear();
     }
     $createTaskId(taskDTO) {
-        return ( new Promise((resolve, reject) => {
-            const task = TaskDTO.to(taskDTO, this._workspaceContextServer, true);
-            if (task) {
-                resolve(task._id);
-            }
-            else {
-                reject(( new Error('Task could not be created from DTO')));
-            }
-        }));
+        return (
+             (new Promise((resolve, reject) => {
+                const task = TaskDTO.to(taskDTO, this._workspaceContextServer, true);
+                if (task) {
+                    resolve(task._id);
+                }
+                else {
+                    reject(( (new Error('Task could not be created from DTO'))));
+                }
+            }))
+        );
     }
     $registerTaskProvider(handle, type) {
         const provider = {
@@ -542,7 +549,7 @@ let MainThreadTask = class MainThreadTask {
         else {
             const workspaceObject = this._workspaceContextServer.getWorkspace();
             const uri = URI.revive(value);
-            if (workspaceObject.configuration?.toString() === ( uri.toString())) {
+            if (workspaceObject.configuration?.toString() === ( (uri.toString()))) {
                 workspace = workspaceObject;
             }
             else {
@@ -562,10 +569,10 @@ let MainThreadTask = class MainThreadTask {
                         task: TaskDTO.from(task)
                     };
                 }
-                throw new Error('Task not found');
+                throw ( (new Error('Task not found')));
             }
             else {
-                throw new Error('No workspace folder');
+                throw ( (new Error('No workspace folder')));
             }
         }
         else {
@@ -577,80 +584,86 @@ let MainThreadTask = class MainThreadTask {
         }
     }
     $executeTask(value) {
-        return ( new Promise((resolve, reject) => {
-            if (TaskHandleDTO.is(value)) {
-                const workspace = this.getWorkspace(value.workspaceFolder);
-                if (workspace) {
-                    this._taskService.getTask(workspace, value.id, true).then((task) => {
-                        if (!task) {
-                            reject(( new Error('Task not found')));
-                        }
-                        else {
-                            const result = {
-                                id: value.id,
-                                task: TaskDTO.from(task)
-                            };
-                            this._taskService.run(task).then(summary => {
-                                if ((summary?.exitCode === undefined) || (summary.exitCode !== 0)) {
-                                    this._proxy.$OnDidEndTask(result);
-                                }
-                            }, reason => {
-                            });
-                            resolve(result);
-                        }
-                    }, (_error) => {
-                        reject(( new Error('Task not found')));
-                    });
+        return (
+             (new Promise((resolve, reject) => {
+                if (TaskHandleDTO.is(value)) {
+                    const workspace = this.getWorkspace(value.workspaceFolder);
+                    if (workspace) {
+                        this._taskService.getTask(workspace, value.id, true).then((task) => {
+                            if (!task) {
+                                reject(( (new Error('Task not found'))));
+                            }
+                            else {
+                                const result = {
+                                    id: value.id,
+                                    task: TaskDTO.from(task)
+                                };
+                                this._taskService.run(task).then(summary => {
+                                    if ((summary?.exitCode === undefined) || (summary.exitCode !== 0)) {
+                                        this._proxy.$OnDidEndTask(result);
+                                    }
+                                }, reason => {
+                                });
+                                resolve(result);
+                            }
+                        }, (_error) => {
+                            reject(( (new Error('Task not found'))));
+                        });
+                    }
+                    else {
+                        reject(( (new Error('No workspace folder'))));
+                    }
                 }
                 else {
-                    reject(( new Error('No workspace folder')));
+                    const task = TaskDTO.to(value, this._workspaceContextServer, true);
+                    this._taskService.run(task).then(undefined, reason => {
+                    });
+                    const result = {
+                        id: task._id,
+                        task: TaskDTO.from(task)
+                    };
+                    resolve(result);
                 }
-            }
-            else {
-                const task = TaskDTO.to(value, this._workspaceContextServer, true);
-                this._taskService.run(task).then(undefined, reason => {
-                });
-                const result = {
-                    id: task._id,
-                    task: TaskDTO.from(task)
-                };
-                resolve(result);
-            }
-        }));
+            }))
+        );
     }
     $customExecutionComplete(id, result) {
-        return ( new Promise((resolve, reject) => {
-            this._taskService.getActiveTasks().then((tasks) => {
-                for (const task of tasks) {
-                    if (id === task._id) {
-                        this._taskService.extensionCallbackTaskComplete(task, result).then((value) => {
-                            resolve(undefined);
-                        }, (error) => {
-                            reject(error);
-                        });
-                        return;
+        return (
+             (new Promise((resolve, reject) => {
+                this._taskService.getActiveTasks().then((tasks) => {
+                    for (const task of tasks) {
+                        if (id === task._id) {
+                            this._taskService.extensionCallbackTaskComplete(task, result).then((value) => {
+                                resolve(undefined);
+                            }, (error) => {
+                                reject(error);
+                            });
+                            return;
+                        }
                     }
-                }
-                reject(( new Error('Task to mark as complete not found')));
-            });
-        }));
+                    reject(( (new Error('Task to mark as complete not found'))));
+                });
+            }))
+        );
     }
     $terminateTask(id) {
-        return ( new Promise((resolve, reject) => {
-            this._taskService.getActiveTasks().then((tasks) => {
-                for (const task of tasks) {
-                    if (id === task._id) {
-                        this._taskService.terminate(task).then((value) => {
-                            resolve(undefined);
-                        }, (error) => {
-                            reject(undefined);
-                        });
-                        return;
+        return (
+             (new Promise((resolve, reject) => {
+                this._taskService.getActiveTasks().then((tasks) => {
+                    for (const task of tasks) {
+                        if (id === task._id) {
+                            this._taskService.terminate(task).then((value) => {
+                                resolve(undefined);
+                            }, (error) => {
+                                reject(undefined);
+                            });
+                            return;
+                        }
                     }
-                }
-                reject(( new ErrorNoTelemetry('Task to terminate not found')));
-            });
-        }));
+                    reject(( (new ErrorNoTelemetry('Task to terminate not found'))));
+                });
+            }))
+        );
     }
     $registerTaskSystem(key, info) {
         let platform$1;
@@ -673,43 +686,47 @@ let MainThreadTask = class MainThreadTask {
         this._taskService.registerTaskSystem(key, {
             platform: platform$1,
             uriProvider: (path) => {
-                return ( URI.from({ scheme: info.scheme, authority: info.authority, path }));
+                return (
+                     (URI.from({ scheme: info.scheme, authority: info.authority, path }))
+                );
             },
             context: this._extHostContext,
             resolveVariables: (workspaceFolder, toResolve, target) => {
                 const vars = [];
                 toResolve.variables.forEach(item => vars.push(item));
                 return Promise.resolve(this._proxy.$resolveVariables(workspaceFolder.uri, { process: toResolve.process, variables: vars })).then(values => {
-                    const partiallyResolvedVars = Array.from(( Object.values(values.variables)));
-                    return ( new Promise((resolve, reject) => {
-                        this._configurationResolverService.resolveWithInteraction(workspaceFolder, partiallyResolvedVars, 'tasks', undefined, target).then(resolvedVars => {
-                            if (!resolvedVars) {
-                                resolve(undefined);
-                            }
-                            const result = {
-                                process: undefined,
-                                variables: ( new Map())
-                            };
-                            for (let i = 0; i < partiallyResolvedVars.length; i++) {
-                                const variableName = vars[i].substring(2, vars[i].length - 1);
-                                if (resolvedVars && values.variables[vars[i]] === vars[i]) {
-                                    const resolved = resolvedVars.get(variableName);
-                                    if (typeof resolved === 'string') {
-                                        result.variables.set(variableName, resolved);
+                    const partiallyResolvedVars = Array.from(( (Object.values(values.variables))));
+                    return (
+                         (new Promise((resolve, reject) => {
+                            this._configurationResolverService.resolveWithInteraction(workspaceFolder, partiallyResolvedVars, 'tasks', undefined, target).then(resolvedVars => {
+                                if (!resolvedVars) {
+                                    resolve(undefined);
+                                }
+                                const result = {
+                                    process: undefined,
+                                    variables: ( (new Map()))
+                                };
+                                for (let i = 0; i < partiallyResolvedVars.length; i++) {
+                                    const variableName = vars[i].substring(2, vars[i].length - 1);
+                                    if (resolvedVars && values.variables[vars[i]] === vars[i]) {
+                                        const resolved = resolvedVars.get(variableName);
+                                        if (typeof resolved === 'string') {
+                                            result.variables.set(variableName, resolved);
+                                        }
+                                    }
+                                    else {
+                                        result.variables.set(variableName, partiallyResolvedVars[i]);
                                     }
                                 }
-                                else {
-                                    result.variables.set(variableName, partiallyResolvedVars[i]);
+                                if (isString(values.process)) {
+                                    result.process = values.process;
                                 }
-                            }
-                            if (isString(values.process)) {
-                                result.process = values.process;
-                            }
-                            resolve(result);
-                        }, reason => {
-                            reject(reason);
-                        });
-                    }));
+                                resolve(result);
+                            }, reason => {
+                                reject(reason);
+                            });
+                        }))
+                    );
                 });
             },
             findExecutable: (command, cwd, paths) => {
@@ -723,9 +740,9 @@ let MainThreadTask = class MainThreadTask {
 };
 MainThreadTask = __decorate([
     extHostNamedCustomer(MainContext.MainThreadTask),
-    ( __param(1, ITaskService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IConfigurationResolverService))
+    ( (__param(1, ITaskService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IConfigurationResolverService)))
 ], MainThreadTask);
 
 export { MainThreadTask };

package/vscode/src/vs/workbench/api/browser/mainThreadTreeViews.js

@@ -103,7 +103,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
     $resolveDropFileData(destinationViewId, requestId, dataItemId) {
         const controller = this._dndControllers.get(destinationViewId);
         if (!controller) {
-            throw new Error('Unknown tree');
+            throw ( new Error('Unknown tree'));
         }
         return controller.resolveDropFileData(requestId, dataItemId);
     }