@codingame/monaco-vscode-extensions-service-override 11.1.2 → 12.0.0

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

@@ -1,12 +1,13 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
 import { isString } from 'vscode/vscode/vs/base/common/types';
-import { platform } from 'vscode/vscode/vs/base/common/platform';
+import { platform, Platform } from 'vscode/vscode/vs/base/common/platform';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { TaskDefinition, PresentationOptions, RunOptions, CommandOptions, RuntimeType, TaskSourceKind, CustomTask, ContributedTask, ConfiguringTask } from 'vscode/vscode/vs/workbench/contrib/tasks/common/tasks';
+import { TaskDefinition, PresentationOptions, RunOptions, CommandOptions, RuntimeType, TaskSourceKind, TaskScope, CustomTask, ContributedTask, ConfiguringTask, TaskEventKind } from 'vscode/vscode/vs/workbench/contrib/tasks/common/tasks';
 import { ITaskService } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
@@ -14,7 +15,7 @@ import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/servic
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
 
 var TaskExecutionDTO;
-( ((function(TaskExecutionDTO) {
+(function (TaskExecutionDTO) {
     function from(value) {
         return {
             id: value.id,
@@ -22,9 +23,9 @@ var TaskExecutionDTO;
         };
     }
     TaskExecutionDTO.from = from;
-})(TaskExecutionDTO || (TaskExecutionDTO = {}))));
+})(TaskExecutionDTO || (TaskExecutionDTO = {}));
 var TaskProcessStartedDTO;
-( ((function(TaskProcessStartedDTO) {
+(function (TaskProcessStartedDTO) {
     function from(value, processId) {
         return {
             id: value.id,
@@ -32,9 +33,9 @@ var TaskProcessStartedDTO;
         };
     }
     TaskProcessStartedDTO.from = from;
-})(TaskProcessStartedDTO || (TaskProcessStartedDTO = {}))));
+})(TaskProcessStartedDTO || (TaskProcessStartedDTO = {}));
 var TaskProcessEndedDTO;
-( ((function(TaskProcessEndedDTO) {
+(function (TaskProcessEndedDTO) {
     function from(value, exitCode) {
         return {
             id: value.id,
@@ -42,9 +43,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;
@@ -62,9 +63,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;
@@ -79,9 +80,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;
@@ -96,9 +97,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;
@@ -119,9 +120,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;
@@ -129,7 +130,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
@@ -151,9 +152,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;
@@ -192,9 +193,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);
@@ -228,9 +229,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';
@@ -249,9 +250,9 @@ var CustomExecutionDTO;
         };
     }
     CustomExecutionDTO.to = to;
-})(CustomExecutionDTO || (CustomExecutionDTO = {}))));
+})(CustomExecutionDTO || (CustomExecutionDTO = {}));
 var TaskSourceDTO;
-( ((function(TaskSourceDTO) {
+(function (TaskSourceDTO) {
     function from(value) {
         const result = {
             label: value.label
@@ -267,7 +268,7 @@ var TaskSourceDTO;
         }
         else if (value.kind === TaskSourceKind.Workspace) {
             result.extensionId = '$core';
-            result.scope = value.config.workspaceFolder ? value.config.workspaceFolder.uri : 1 ;
+            result.scope = value.config.workspaceFolder ? value.config.workspaceFolder.uri : TaskScope.Global;
         }
         return result;
     }
@@ -275,13 +276,13 @@ var TaskSourceDTO;
     function to(value, workspace) {
         let scope;
         let workspaceFolder;
-        if ((value.scope === undefined) || ((typeof value.scope === 'number') && ((value.scope !== 1) ))) {
+        if ((value.scope === undefined) || ((typeof value.scope === 'number') && (value.scope !== TaskScope.Global))) {
             if (workspace.getWorkspace().folders.length === 0) {
-                scope = 1 ;
+                scope = TaskScope.Global;
                 workspaceFolder = undefined;
             }
             else {
-                scope = 3 ;
+                scope = TaskScope.Folder;
                 workspaceFolder = workspace.getWorkspace().folders[0];
             }
         }
@@ -289,7 +290,7 @@ var TaskSourceDTO;
             scope = value.scope;
         }
         else {
-            scope = 3 ;
+            scope = TaskScope.Folder;
             workspaceFolder = workspace.getWorkspaceFolder(URI.revive(value.scope)) ?? undefined;
         }
         const result = {
@@ -302,17 +303,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;
@@ -377,36 +378,26 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( localize(4555, '{0}: {1}', source.label, task.name));
+        const label = ( localize(2299, '{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;
@@ -417,9 +408,9 @@ var TaskGroupDTO;
         };
     }
     TaskGroupDTO.from = from;
-})(TaskGroupDTO || (TaskGroupDTO = {}))));
+})(TaskGroupDTO || (TaskGroupDTO = {}));
 var TaskFilterDTO;
-( ((function(TaskFilterDTO) {
+(function (TaskFilterDTO) {
     function from(value) {
         return value;
     }
@@ -428,21 +419,21 @@ var TaskFilterDTO;
         return value;
     }
     TaskFilterDTO.to = to;
-})(TaskFilterDTO || (TaskFilterDTO = {}))));
+})(TaskFilterDTO || (TaskFilterDTO = {}));
 let MainThreadTask = class MainThreadTask extends Disposable {
     constructor(extHostContext, _taskService, _workspaceContextServer, _configurationResolverService) {
         super();
         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._register(this._taskService.onDidStateChange(async (event) => {
-            if (event.kind === "changed" ) {
+            if (event.kind === TaskEventKind.Changed) {
                 return;
             }
             const task = event.__task;
-            if (event.kind === "start" ) {
+            if (event.kind === TaskEventKind.Start) {
                 const execution = TaskExecutionDTO.from(task.getTaskExecution());
                 let resolvedDefinition = execution.task.definition;
                 if (execution.task?.execution && CustomExecutionDTO.is(execution.task.execution) && event.resolvedVariables) {
@@ -454,36 +445,34 @@ let MainThreadTask = class MainThreadTask extends Disposable {
                 }
                 this._proxy.$onDidStartTask(execution, event.terminalId, resolvedDefinition);
             }
-            else if (event.kind === "processStarted" ) {
+            else if (event.kind === TaskEventKind.ProcessStarted) {
                 this._proxy.$onDidStartTaskProcess(TaskProcessStartedDTO.from(task.getTaskExecution(), event.processId));
             }
-            else if (event.kind === "processEnded" ) {
+            else if (event.kind === TaskEventKind.ProcessEnded) {
                 this._proxy.$onDidEndTaskProcess(TaskProcessEndedDTO.from(task.getTaskExecution(), event.exitCode));
             }
-            else if (event.kind === "end" ) {
+            else if (event.kind === TaskEventKind.End) {
                 this._proxy.$OnDidEndTask(TaskExecutionDTO.from(task.getTaskExecution()));
             }
         }));
     }
     dispose() {
-        for (const value of ( (this._providers.values()))) {
+        for (const value of ( this._providers.values())) {
             value.disposable.dispose();
         }
         this._providers.clear();
         super.dispose();
     }
     $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 = {
@@ -555,7 +544,7 @@ let MainThreadTask = class MainThreadTask extends Disposable {
         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 {
@@ -575,10 +564,10 @@ let MainThreadTask = class MainThreadTask extends Disposable {
                         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 {
@@ -590,101 +579,95 @@ let MainThreadTask = class MainThreadTask extends Disposable {
         }
     }
     $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'))));
-                        });
-                    }
-                    else {
-                        reject(( (new Error('No workspace folder'))));
-                    }
+        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 {
-                    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);
+                    reject(( new Error('No workspace folder')));
                 }
-            }))
-        );
+            }
+            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;
         switch (info.platform) {
             case 'Web':
-                platform$1 = 0 ;
+                platform$1 = Platform.Web;
                 break;
             case 'win32':
-                platform$1 = 3 ;
+                platform$1 = Platform.Windows;
                 break;
             case 'darwin':
-                platform$1 = 1 ;
+                platform$1 = Platform.Mac;
                 break;
             case 'linux':
-                platform$1 = 2 ;
+                platform$1 = Platform.Linux;
                 break;
             default:
                 platform$1 = platform;
@@ -692,47 +675,43 @@ let MainThreadTask = class MainThreadTask extends Disposable {
         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);
-                                        }
-                                    }
-                                    else {
-                                        result.variables.set(variableName, partiallyResolvedVars[i]);
+                    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);
                                     }
                                 }
-                                if (isString(values.process)) {
-                                    result.process = values.process;
+                                else {
+                                    result.variables.set(variableName, partiallyResolvedVars[i]);
                                 }
-                                resolve(result);
-                            }, reason => {
-                                reject(reason);
-                            });
-                        }))
-                    );
+                            }
+                            if (isString(values.process)) {
+                                result.process = values.process;
+                            }
+                            resolve(result);
+                        }, reason => {
+                            reject(reason);
+                        });
+                    }));
                 });
             },
             findExecutable: (command, cwd, paths) => {
@@ -746,9 +725,9 @@ let MainThreadTask = class MainThreadTask extends Disposable {
 };
 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/mainThreadTelemetry.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IEnvironmentService } from "vscode/vscode/vs/platform/environment/common/environment.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from "vscode/vscode/vs/platform/telemetry/common/gdprTypings";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { MainThreadTelemetryShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadTelemetry extends Disposable implements MainThreadTelemetryShape {
+    private readonly _telemetryService;
+    private readonly _configurationService;
+    private readonly _environmentService;
+    private readonly _productService;
+    private readonly _proxy;
+    private static readonly _name;
+    constructor(extHostContext: IExtHostContext, _telemetryService: ITelemetryService, _configurationService: IConfigurationService, _environmentService: IEnvironmentService, _productService: IProductService);
+    private get telemetryLevel();
+    $publicLog(eventName: string, data?: any): void;
+    $publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+}