@codingame/monaco-vscode-extensions-service-override
Version:
VSCode public API plugged on the monaco editor - extensions service-override
773 lines (769 loc) • 30.9 kB
JavaScript
import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
import { platform, Platform } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
import { TaskDefinition, PresentationOptions, RunOptions, CommandOptions, RuntimeType, TaskSourceKind, TaskScope, CustomTask, ContributedTask, ConfiguringTask } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/tasks';
import { ITaskService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskService.service';
import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
import { TaskEventKind } from '../common/shared/tasks.js';
import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
var TaskExecutionDTO;
(function(TaskExecutionDTO) {
function from(value) {
return {
id: value.id,
task: TaskDTO.from(value.task)
};
}
TaskExecutionDTO.from = from;
})(TaskExecutionDTO || (TaskExecutionDTO = {}));
var TaskProblemMatcherStartedDto;
(function(TaskProblemMatcherStartedDto) {
function from(value) {
return {
execution: {
id: value.execution.id,
task: TaskDTO.from(value.execution.task)
}
};
}
TaskProblemMatcherStartedDto.from = from;
})(TaskProblemMatcherStartedDto || (TaskProblemMatcherStartedDto = {}));
var TaskProblemMatcherEndedDto;
(function(TaskProblemMatcherEndedDto) {
function from(value) {
return {
execution: {
id: value.execution.id,
task: TaskDTO.from(value.execution.task)
},
hasErrors: value.hasErrors
};
}
TaskProblemMatcherEndedDto.from = from;
})(TaskProblemMatcherEndedDto || (TaskProblemMatcherEndedDto = {}));
var TaskProcessStartedDTO;
(function(TaskProcessStartedDTO) {
function from(value, processId) {
return {
id: value.id,
processId
};
}
TaskProcessStartedDTO.from = from;
})(TaskProcessStartedDTO || (TaskProcessStartedDTO = {}));
var TaskProcessEndedDTO;
(function(TaskProcessEndedDTO) {
function from(value, exitCode) {
return {
id: value.id,
exitCode
};
}
TaskProcessEndedDTO.from = from;
})(TaskProcessEndedDTO || (TaskProcessEndedDTO = {}));
var TaskDefinitionDTO;
(function(TaskDefinitionDTO) {
function from(value) {
const result = Object.assign(Object.create(null), value);
delete result._key;
return result;
}
TaskDefinitionDTO.from = from;
function to(value, executeOnly) {
let result = TaskDefinition.createTaskIdentifier(value, console);
if (result === undefined && executeOnly) {
result = {
_key: generateUuid(),
type: "$executeOnly"
};
}
return result;
}
TaskDefinitionDTO.to = to;
})(TaskDefinitionDTO || (TaskDefinitionDTO = {}));
var TaskPresentationOptionsDTO;
(function(TaskPresentationOptionsDTO) {
function from(value) {
if (value === undefined || value === null) {
return undefined;
}
return Object.assign(Object.create(null), value);
}
TaskPresentationOptionsDTO.from = from;
function to(value) {
if (value === undefined || value === null) {
return PresentationOptions.defaults;
}
return Object.assign(Object.create(null), PresentationOptions.defaults, value);
}
TaskPresentationOptionsDTO.to = to;
})(TaskPresentationOptionsDTO || (TaskPresentationOptionsDTO = {}));
var RunOptionsDTO;
(function(RunOptionsDTO) {
function from(value) {
if (value === undefined || value === null) {
return undefined;
}
return Object.assign(Object.create(null), value);
}
RunOptionsDTO.from = from;
function to(value) {
if (value === undefined || value === null) {
return RunOptions.defaults;
}
return Object.assign(Object.create(null), RunOptions.defaults, value);
}
RunOptionsDTO.to = to;
})(RunOptionsDTO || (RunOptionsDTO = {}));
var ProcessExecutionOptionsDTO;
(function(ProcessExecutionOptionsDTO) {
function from(value) {
if (value === undefined || value === null) {
return undefined;
}
return {
cwd: value.cwd,
env: value.env
};
}
ProcessExecutionOptionsDTO.from = from;
function to(value) {
if (value === undefined || value === null) {
return CommandOptions.defaults;
}
return {
cwd: value.cwd || CommandOptions.defaults.cwd,
env: value.env
};
}
ProcessExecutionOptionsDTO.to = to;
})(ProcessExecutionOptionsDTO || (ProcessExecutionOptionsDTO = {}));
var ProcessExecutionDTO;
(function(ProcessExecutionDTO) {
function is(value) {
const candidate = value;
return candidate && !!candidate.process;
}
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 result = {
process: process,
args: args
};
if (value.options) {
result.options = ProcessExecutionOptionsDTO.from(value.options);
}
return result;
}
ProcessExecutionDTO.from = from;
function to(value) {
const result = {
runtime: RuntimeType.Process,
name: value.process,
args: value.args,
presentation: undefined
};
result.options = ProcessExecutionOptionsDTO.to(value.options);
return result;
}
ProcessExecutionDTO.to = to;
})(ProcessExecutionDTO || (ProcessExecutionDTO = {}));
var ShellExecutionOptionsDTO;
(function(ShellExecutionOptionsDTO) {
function from(value) {
if (value === undefined || value === null) {
return undefined;
}
const result = {
cwd: value.cwd || CommandOptions.defaults.cwd,
env: value.env
};
if (value.shell) {
result.executable = value.shell.executable;
result.shellArgs = value.shell.args;
result.shellQuoting = value.shell.quoting;
}
return result;
}
ShellExecutionOptionsDTO.from = from;
function to(value) {
if (value === undefined || value === null) {
return undefined;
}
const result = {
cwd: value.cwd,
env: value.env
};
if (value.executable) {
result.shell = {
executable: value.executable
};
if (value.shellArgs) {
result.shell.args = value.shellArgs;
}
if (value.shellQuoting) {
result.shell.quoting = value.shellQuoting;
}
}
return result;
}
ShellExecutionOptionsDTO.to = to;
})(ShellExecutionOptionsDTO || (ShellExecutionOptionsDTO = {}));
var ShellExecutionDTO;
(function(ShellExecutionDTO) {
function is(value) {
const candidate = value;
return candidate && (!!candidate.commandLine || !!candidate.command);
}
ShellExecutionDTO.is = is;
function from(value) {
const result = {};
if (value.name && isString(value.name) && (value.args === undefined || value.args === null || value.args.length === 0)) {
result.commandLine = value.name;
} else {
result.command = value.name;
result.args = value.args;
}
if (value.options) {
result.options = ShellExecutionOptionsDTO.from(value.options);
}
return result;
}
ShellExecutionDTO.from = from;
function to(value) {
const result = {
runtime: RuntimeType.Shell,
name: value.commandLine ? value.commandLine : value.command,
args: value.args,
presentation: undefined
};
if (value.options) {
result.options = ShellExecutionOptionsDTO.to(value.options);
}
return result;
}
ShellExecutionDTO.to = to;
})(ShellExecutionDTO || (ShellExecutionDTO = {}));
var CustomExecutionDTO;
(function(CustomExecutionDTO) {
function is(value) {
const candidate = value;
return candidate && candidate.customExecution === "customExecution";
}
CustomExecutionDTO.is = is;
function from(value) {
return {
customExecution: "customExecution"
};
}
CustomExecutionDTO.from = from;
function to(value) {
return {
runtime: RuntimeType.CustomExecution,
presentation: undefined
};
}
CustomExecutionDTO.to = to;
})(CustomExecutionDTO || (CustomExecutionDTO = {}));
var TaskSourceDTO;
(function(TaskSourceDTO) {
function from(value) {
const result = {
label: value.label
};
if (value.kind === TaskSourceKind.Extension) {
result.extensionId = value.extension;
if (value.workspaceFolder) {
result.scope = value.workspaceFolder.uri;
} else {
result.scope = value.scope;
}
} else if (value.kind === TaskSourceKind.Workspace) {
result.extensionId = "$core";
result.scope = value.config.workspaceFolder ? value.config.workspaceFolder.uri : TaskScope.Global;
}
return result;
}
TaskSourceDTO.from = from;
function to(value, workspace) {
let scope;
let workspaceFolder;
if ((value.scope === undefined) || ((typeof value.scope === "number") && (value.scope !== TaskScope.Global))) {
if (workspace.getWorkspace().folders.length === 0) {
scope = TaskScope.Global;
workspaceFolder = undefined;
} else {
scope = TaskScope.Folder;
workspaceFolder = workspace.getWorkspace().folders[0];
}
} else if (typeof value.scope === "number") {
scope = value.scope;
} else {
scope = TaskScope.Folder;
workspaceFolder = workspace.getWorkspaceFolder(URI.revive(value.scope)) ?? undefined;
}
const result = {
kind: TaskSourceKind.Extension,
label: value.label,
extension: value.extensionId,
scope,
workspaceFolder
};
return result;
}
TaskSourceDTO.to = to;
})(TaskSourceDTO || (TaskSourceDTO = {}));
var TaskHandleDTO;
(function(TaskHandleDTO) {
function is(value) {
const candidate = value;
return !!candidate && isString(candidate.id) && !!candidate.workspaceFolder;
}
TaskHandleDTO.is = is;
})(TaskHandleDTO || (TaskHandleDTO = {}));
var TaskDTO;
(function(TaskDTO) {
function from(task) {
if (task === undefined || task === null || (!CustomTask.is(task) && !ContributedTask.is(task) && !ConfiguringTask.is(task))) {
return undefined;
}
const result = {
_id: task._id,
name: task.configurationProperties.name,
definition: TaskDefinitionDTO.from(task.getDefinition(true)),
source: TaskSourceDTO.from(task._source),
execution: undefined,
presentationOptions: !ConfiguringTask.is(task) && task.command ? TaskPresentationOptionsDTO.from(task.command.presentation) : undefined,
isBackground: task.configurationProperties.isBackground,
problemMatchers: [],
hasDefinedMatchers: ContributedTask.is(task) ? task.hasDefinedMatchers : false,
runOptions: RunOptionsDTO.from(task.runOptions)
};
result.group = TaskGroupDTO.from(task.configurationProperties.group);
if (task.configurationProperties.detail) {
result.detail = task.configurationProperties.detail;
}
if (!ConfiguringTask.is(task) && task.command) {
switch (task.command.runtime) {
case RuntimeType.Process:
result.execution = ProcessExecutionDTO.from(task.command);
break;
case RuntimeType.Shell:
result.execution = ShellExecutionDTO.from(task.command);
break;
case RuntimeType.CustomExecution:
result.execution = CustomExecutionDTO.from(task.command);
break;
}
}
if (task.configurationProperties.problemMatchers) {
for (const matcher of task.configurationProperties.problemMatchers) {
if (isString(matcher)) {
result.problemMatchers.push(matcher);
}
}
}
return result;
}
TaskDTO.from = from;
function to(task, workspace, executeOnly, icon, hide) {
if (!task || (typeof task.name !== "string")) {
return undefined;
}
let command;
if (task.execution) {
if (ShellExecutionDTO.is(task.execution)) {
command = ShellExecutionDTO.to(task.execution);
} else if (ProcessExecutionDTO.is(task.execution)) {
command = ProcessExecutionDTO.to(task.execution);
} else if (CustomExecutionDTO.is(task.execution)) {
command = CustomExecutionDTO.to(task.execution);
}
}
if (!command) {
return undefined;
}
command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
const source = TaskSourceDTO.to(task.source, workspace);
const label = ( localize(2643, "{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
}));
return result;
}
TaskDTO.to = to;
})(TaskDTO || (TaskDTO = {}));
var TaskGroupDTO;
(function(TaskGroupDTO) {
function from(value) {
if (value === undefined) {
return undefined;
}
return {
_id: (typeof value === "string") ? value : value._id,
isDefault: (typeof value === "string") ? false : ((typeof value.isDefault === "string") ? false : value.isDefault)
};
}
TaskGroupDTO.from = from;
})(TaskGroupDTO || (TaskGroupDTO = {}));
var TaskFilterDTO;
(function(TaskFilterDTO) {
function from(value) {
return value;
}
TaskFilterDTO.from = from;
function to(value) {
return value;
}
TaskFilterDTO.to = to;
})(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._register(this._taskService.onDidStateChange(async event => {
if (event.kind === TaskEventKind.Changed) {
return;
}
const task = event.__task;
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) {
const expr = ConfigurationResolverExpression.parse(execution.task.definition);
for (const replacement of expr.unresolved()) {
const value = event.resolvedVariables.get(replacement.inner);
if (value !== undefined) {
expr.resolve(replacement, value);
}
}
resolvedDefinition = await this._configurationResolverService.resolveAsync(task.getWorkspaceFolder(), expr);
}
this._proxy.$onDidStartTask(execution, event.terminalId, resolvedDefinition);
} else if (event.kind === TaskEventKind.ProcessStarted) {
this._proxy.$onDidStartTaskProcess(TaskProcessStartedDTO.from(task.getTaskExecution(), event.processId));
} else if (event.kind === TaskEventKind.ProcessEnded) {
this._proxy.$onDidEndTaskProcess(TaskProcessEndedDTO.from(task.getTaskExecution(), event.exitCode));
} else if (event.kind === TaskEventKind.End) {
this._proxy.$OnDidEndTask(TaskExecutionDTO.from(task.getTaskExecution()));
} else if (event.kind === TaskEventKind.ProblemMatcherStarted) {
this._proxy.$onDidStartTaskProblemMatchers(TaskProblemMatcherStartedDto.from({
execution: task.getTaskExecution()
}));
} else if (event.kind === TaskEventKind.ProblemMatcherEnded) {
this._proxy.$onDidEndTaskProblemMatchers(TaskProblemMatcherEndedDto.from({
execution: task.getTaskExecution(),
hasErrors: false
}));
} else if (event.kind === TaskEventKind.ProblemMatcherFoundErrors) {
this._proxy.$onDidEndTaskProblemMatchers(TaskProblemMatcherEndedDto.from({
execution: task.getTaskExecution(),
hasErrors: true
}));
}
}));
}
dispose() {
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")));
}
}));
}
$registerTaskProvider(handle, type) {
const provider = {
provideTasks: validTypes => {
return Promise.resolve(this._proxy.$provideTasks(handle, validTypes)).then(value => {
const tasks = [];
for (const dto of value.tasks) {
const task = TaskDTO.to(dto, this._workspaceContextServer, true);
if (task) {
tasks.push(task);
} else {
console.error(
`Task System: can not convert task: ${JSON.stringify(dto.definition, undefined, 0)}. Task will be dropped`
);
}
}
const processedExtension = {
...value.extension,
extensionLocation: URI.revive(value.extension.extensionLocation)
};
return {
tasks,
extension: processedExtension
};
});
},
resolveTask: task => {
const dto = TaskDTO.from(task);
if (dto) {
dto.name = ((dto.name === undefined) ? "" : dto.name);
return Promise.resolve(this._proxy.$resolveTask(handle, dto)).then(resolvedTask => {
if (resolvedTask) {
return TaskDTO.to(
resolvedTask,
this._workspaceContextServer,
true,
task.configurationProperties.icon,
task.configurationProperties.hide
);
}
return undefined;
});
}
return Promise.resolve(undefined);
}
};
const disposable = this._taskService.registerTaskProvider(provider, type);
this._providers.set(handle, {
disposable,
provider
});
return Promise.resolve(undefined);
}
$unregisterTaskProvider(handle) {
const provider = this._providers.get(handle);
if (provider) {
provider.disposable.dispose();
this._providers.delete(handle);
}
return Promise.resolve(undefined);
}
$fetchTasks(filter) {
return this._taskService.tasks(TaskFilterDTO.to(filter)).then(tasks => {
const result = [];
for (const task of tasks) {
const item = TaskDTO.from(task);
if (item) {
result.push(item);
}
}
return result;
});
}
getWorkspace(value) {
let workspace;
if (typeof value === "string") {
workspace = value;
} else {
const workspaceObject = this._workspaceContextServer.getWorkspace();
const uri = URI.revive(value);
if (workspaceObject.configuration?.toString() === ( uri.toString())) {
workspace = workspaceObject;
} else {
workspace = this._workspaceContextServer.getWorkspaceFolder(uri);
}
}
return workspace;
}
async $getTaskExecution(value) {
if (TaskHandleDTO.is(value)) {
const workspace = this.getWorkspace(value.workspaceFolder);
if (workspace) {
const task = await this._taskService.getTask(workspace, value.id, true);
if (task) {
return {
id: task._id,
task: TaskDTO.from(task)
};
}
throw ( new Error("Task not found"));
} else {
throw ( new Error("No workspace folder"));
}
} else {
const task = TaskDTO.to(value, this._workspaceContextServer, true);
return {
id: task._id,
task: TaskDTO.from(task)
};
}
}
$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")));
}
} 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;
}
}
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;
}
}
reject(( new ErrorNoTelemetry("Task to terminate not found")));
});
}));
}
$registerTaskSystem(key, info) {
let platform$1;
switch (info.platform) {
case "Web":
platform$1 = Platform.Web;
break;
case "win32":
platform$1 = Platform.Windows;
break;
case "darwin":
platform$1 = Platform.Mac;
break;
case "linux":
platform$1 = Platform.Linux;
break;
default:
platform$1 = platform;
}
this._taskService.registerTaskSystem(key, {
platform: platform$1,
uriProvider: 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]);
}
}
if (isString(values.process)) {
result.process = values.process;
}
resolve(result);
}, reason => {
reject(reason);
});
}));
});
},
findExecutable: (command, cwd, paths) => {
return this._proxy.$findExecutable(command, cwd, paths);
}
});
}
async $registerSupportedExecutions(custom, shell, process) {
return this._taskService.registerSupportedExecutions(custom, shell, process);
}
};
MainThreadTask = __decorate([extHostNamedCustomer(MainContext.MainThreadTask), ( __param(1, ITaskService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IConfigurationResolverService))], MainThreadTask);
export { MainThreadTask, TaskProblemMatcherEndedDto, TaskProblemMatcherStartedDto };