@codingame/monaco-vscode-api 1.85.1 → 1.85.2

package/vscode/src/vs/workbench/contrib/tasks/common/tasks.js

@@ -0,0 +1,712 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as Types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import * as Objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { TaskDefinitionRegistry } from './taskDefinitionRegistry.js';
+const USER_TASKS_GROUP_KEY = 'settings';
+const TASK_RUNNING_STATE = ( new RawContextKey('taskRunning', false, ( nls.localizeWithPath(
+    'vs/workbench/contrib/tasks/common/tasks',
+    'tasks.taskRunningContext',
+    "Whether a task is currently running."
+))));
+const TASKS_CATEGORY = { value: ( nls.localizeWithPath('vs/workbench/contrib/tasks/common/tasks', 'tasksCategory', "Tasks")), original: 'Tasks' };
+var ShellQuoting;
+( (function(ShellQuoting) {
+    ShellQuoting[ShellQuoting["Escape"] = 1] = "Escape";
+    ShellQuoting[ShellQuoting["Strong"] = 2] = "Strong";
+    ShellQuoting[ShellQuoting["Weak"] = 3] = "Weak";
+})(ShellQuoting || (ShellQuoting = {})));
+const CUSTOMIZED_TASK_TYPE = '$customized';
+( (function(ShellQuoting) {
+    function from(value) {
+        if (!value) {
+            return ShellQuoting.Strong;
+        }
+        switch (value.toLowerCase()) {
+            case 'escape':
+                return ShellQuoting.Escape;
+            case 'strong':
+                return ShellQuoting.Strong;
+            case 'weak':
+                return ShellQuoting.Weak;
+            default:
+                return ShellQuoting.Strong;
+        }
+    }
+    ShellQuoting.from = from;
+})(ShellQuoting || (ShellQuoting = {})));
+var CommandOptions;
+( (function(CommandOptions) {
+    CommandOptions.defaults = { cwd: '${workspaceFolder}' };
+})(CommandOptions || (CommandOptions = {})));
+var RevealKind;
+( (function(RevealKind) {
+    RevealKind[RevealKind["Always"] = 1] = "Always";
+    RevealKind[RevealKind["Silent"] = 2] = "Silent";
+    RevealKind[RevealKind["Never"] = 3] = "Never";
+})(RevealKind || (RevealKind = {})));
+( (function(RevealKind) {
+    function fromString(value) {
+        switch (value.toLowerCase()) {
+            case 'always':
+                return RevealKind.Always;
+            case 'silent':
+                return RevealKind.Silent;
+            case 'never':
+                return RevealKind.Never;
+            default:
+                return RevealKind.Always;
+        }
+    }
+    RevealKind.fromString = fromString;
+})(RevealKind || (RevealKind = {})));
+var RevealProblemKind;
+( (function(RevealProblemKind) {
+    RevealProblemKind[RevealProblemKind["Never"] = 1] = "Never";
+    RevealProblemKind[RevealProblemKind["OnProblem"] = 2] = "OnProblem";
+    RevealProblemKind[RevealProblemKind["Always"] = 3] = "Always";
+})(RevealProblemKind || (RevealProblemKind = {})));
+( (function(RevealProblemKind) {
+    function fromString(value) {
+        switch (value.toLowerCase()) {
+            case 'always':
+                return RevealProblemKind.Always;
+            case 'never':
+                return RevealProblemKind.Never;
+            case 'onproblem':
+                return RevealProblemKind.OnProblem;
+            default:
+                return RevealProblemKind.OnProblem;
+        }
+    }
+    RevealProblemKind.fromString = fromString;
+})(RevealProblemKind || (RevealProblemKind = {})));
+var PanelKind;
+( (function(PanelKind) {
+    PanelKind[PanelKind["Shared"] = 1] = "Shared";
+    PanelKind[PanelKind["Dedicated"] = 2] = "Dedicated";
+    PanelKind[PanelKind["New"] = 3] = "New";
+})(PanelKind || (PanelKind = {})));
+( (function(PanelKind) {
+    function fromString(value) {
+        switch (value.toLowerCase()) {
+            case 'shared':
+                return PanelKind.Shared;
+            case 'dedicated':
+                return PanelKind.Dedicated;
+            case 'new':
+                return PanelKind.New;
+            default:
+                return PanelKind.Shared;
+        }
+    }
+    PanelKind.fromString = fromString;
+})(PanelKind || (PanelKind = {})));
+var PresentationOptions;
+( (function(PresentationOptions) {
+    PresentationOptions.defaults = {
+        echo: true, reveal: RevealKind.Always, revealProblems: RevealProblemKind.Never, focus: false, panel: PanelKind.Shared, showReuseMessage: true, clear: false
+    };
+})(PresentationOptions || (PresentationOptions = {})));
+var RuntimeType;
+( (function(RuntimeType) {
+    RuntimeType[RuntimeType["Shell"] = 1] = "Shell";
+    RuntimeType[RuntimeType["Process"] = 2] = "Process";
+    RuntimeType[RuntimeType["CustomExecution"] = 3] = "CustomExecution";
+})(RuntimeType || (RuntimeType = {})));
+( (function(RuntimeType) {
+    function fromString(value) {
+        switch (value.toLowerCase()) {
+            case 'shell':
+                return RuntimeType.Shell;
+            case 'process':
+                return RuntimeType.Process;
+            case 'customExecution':
+                return RuntimeType.CustomExecution;
+            default:
+                return RuntimeType.Process;
+        }
+    }
+    RuntimeType.fromString = fromString;
+    function toString(value) {
+        switch (value) {
+            case RuntimeType.Shell: return 'shell';
+            case RuntimeType.Process: return 'process';
+            case RuntimeType.CustomExecution: return 'customExecution';
+            default: return 'process';
+        }
+    }
+    RuntimeType.toString = toString;
+})(RuntimeType || (RuntimeType = {})));
+var CommandString;
+( (function(CommandString) {
+    function value(value) {
+        if (Types.isString(value)) {
+            return value;
+        }
+        else {
+            return value.value;
+        }
+    }
+    CommandString.value = value;
+})(CommandString || (CommandString = {})));
+var TaskGroup;
+( (function(TaskGroup) {
+    TaskGroup.Clean = { _id: 'clean', isDefault: false };
+    TaskGroup.Build = { _id: 'build', isDefault: false };
+    TaskGroup.Rebuild = { _id: 'rebuild', isDefault: false };
+    TaskGroup.Test = { _id: 'test', isDefault: false };
+    function is(value) {
+        return value === TaskGroup.Clean._id || value === TaskGroup.Build._id || value === TaskGroup.Rebuild._id || value === TaskGroup.Test._id;
+    }
+    TaskGroup.is = is;
+    function from(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        else if (Types.isString(value)) {
+            if (is(value)) {
+                return { _id: value, isDefault: false };
+            }
+            return undefined;
+        }
+        else {
+            return value;
+        }
+    }
+    TaskGroup.from = from;
+})(TaskGroup || (TaskGroup = {})));
+var TaskSourceKind;
+( (function(TaskSourceKind) {
+    TaskSourceKind.Workspace = 'workspace';
+    TaskSourceKind.Extension = 'extension';
+    TaskSourceKind.InMemory = 'inMemory';
+    TaskSourceKind.WorkspaceFile = 'workspaceFile';
+    TaskSourceKind.User = 'user';
+    function toConfigurationTarget(kind) {
+        switch (kind) {
+            case TaskSourceKind.User: return 2 ;
+            case TaskSourceKind.WorkspaceFile: return 5 ;
+            default: return 6 ;
+        }
+    }
+    TaskSourceKind.toConfigurationTarget = toConfigurationTarget;
+})(TaskSourceKind || (TaskSourceKind = {})));
+var RunOnOptions;
+( (function(RunOnOptions) {
+    RunOnOptions[RunOnOptions["default"] = 1] = "default";
+    RunOnOptions[RunOnOptions["folderOpen"] = 2] = "folderOpen";
+})(RunOnOptions || (RunOnOptions = {})));
+var RunOptions;
+( (function(RunOptions) {
+    RunOptions.defaults = { reevaluateOnRerun: true, runOn: RunOnOptions.default, instanceLimit: 1 };
+})(RunOptions || (RunOptions = {})));
+class CommonTask {
+    constructor(id, label, type, runOptions, configurationProperties, source) {
+        this._label = '';
+        this._id = id;
+        if (label) {
+            this._label = label;
+        }
+        if (type) {
+            this.type = type;
+        }
+        this.runOptions = runOptions;
+        this.configurationProperties = configurationProperties;
+        this._source = source;
+    }
+    getDefinition(useSource) {
+        return undefined;
+    }
+    getMapKey() {
+        return this._id;
+    }
+    getKey() {
+        return undefined;
+    }
+    getCommonTaskId() {
+        const key = { folder: this.getFolderId(), id: this._id };
+        return JSON.stringify(key);
+    }
+    clone() {
+        return this.fromObject(Object.assign({}, this));
+    }
+    getWorkspaceFolder() {
+        return undefined;
+    }
+    getWorkspaceFileName() {
+        return undefined;
+    }
+    getTelemetryKind() {
+        return 'unknown';
+    }
+    matches(key, compareId = false) {
+        if (key === undefined) {
+            return false;
+        }
+        if (Types.isString(key)) {
+            return key === this._label || key === this.configurationProperties.identifier || (compareId && key === this._id);
+        }
+        const identifier = this.getDefinition(true);
+        return identifier !== undefined && identifier._key === key._key;
+    }
+    getQualifiedLabel() {
+        const workspaceFolder = this.getWorkspaceFolder();
+        if (workspaceFolder) {
+            return `${this._label} (${workspaceFolder.name})`;
+        }
+        else {
+            return this._label;
+        }
+    }
+    getTaskExecution() {
+        const result = {
+            id: this._id,
+            task: this
+        };
+        return result;
+    }
+    addTaskLoadMessages(messages) {
+        if (this._taskLoadMessages === undefined) {
+            this._taskLoadMessages = [];
+        }
+        if (messages) {
+            this._taskLoadMessages = this._taskLoadMessages.concat(messages);
+        }
+    }
+    get taskLoadMessages() {
+        return this._taskLoadMessages;
+    }
+}
+class CustomTask extends CommonTask {
+    constructor(id, source, label, type, command, hasDefinedMatchers, runOptions, configurationProperties) {
+        super(id, label, undefined, runOptions, configurationProperties, source);
+        this.command = {};
+        this._source = source;
+        this.hasDefinedMatchers = hasDefinedMatchers;
+        if (command) {
+            this.command = command;
+        }
+    }
+    clone() {
+        return ( new CustomTask(
+            this._id,
+            this._source,
+            this._label,
+            this.type,
+            this.command,
+            this.hasDefinedMatchers,
+            this.runOptions,
+            this.configurationProperties
+        ));
+    }
+    customizes() {
+        if (this._source && this._source.customizes) {
+            return this._source.customizes;
+        }
+        return undefined;
+    }
+    getDefinition(useSource = false) {
+        if (useSource && this._source.customizes !== undefined) {
+            return this._source.customizes;
+        }
+        else {
+            let type;
+            const commandRuntime = this.command ? this.command.runtime : undefined;
+            switch (commandRuntime) {
+                case RuntimeType.Shell:
+                    type = 'shell';
+                    break;
+                case RuntimeType.Process:
+                    type = 'process';
+                    break;
+                case RuntimeType.CustomExecution:
+                    type = 'customExecution';
+                    break;
+                case undefined:
+                    type = '$composite';
+                    break;
+                default:
+                    throw new Error('Unexpected task runtime');
+            }
+            const result = {
+                type,
+                _key: this._id,
+                id: this._id
+            };
+            return result;
+        }
+    }
+    static is(value) {
+        return value instanceof CustomTask;
+    }
+    getMapKey() {
+        const workspaceFolder = this._source.config.workspaceFolder;
+        return workspaceFolder ? `${( workspaceFolder.uri.toString())}|${this._id}|${this.instance}` : `${this._id}|${this.instance}`;
+    }
+    getFolderId() {
+        return this._source.kind === TaskSourceKind.User ? USER_TASKS_GROUP_KEY : this._source.config.workspaceFolder?.uri.toString();
+    }
+    getCommonTaskId() {
+        return this._source.customizes ? super.getCommonTaskId() : (this.getKey() ?? super.getCommonTaskId());
+    }
+    getKey() {
+        const workspaceFolder = this.getFolderId();
+        if (!workspaceFolder) {
+            return undefined;
+        }
+        let id = this.configurationProperties.identifier;
+        if (this._source.kind !== TaskSourceKind.Workspace) {
+            id += this._source.kind;
+        }
+        const key = { type: CUSTOMIZED_TASK_TYPE, folder: workspaceFolder, id };
+        return JSON.stringify(key);
+    }
+    getWorkspaceFolder() {
+        return this._source.config.workspaceFolder;
+    }
+    getWorkspaceFileName() {
+        return (this._source.config.workspace && this._source.config.workspace.configuration) ? resources.basename(this._source.config.workspace.configuration) : undefined;
+    }
+    getTelemetryKind() {
+        if (this._source.customizes) {
+            return 'workspace>extension';
+        }
+        else {
+            return 'workspace';
+        }
+    }
+    fromObject(object) {
+        return ( new CustomTask(
+            object._id,
+            object._source,
+            object._label,
+            object.type,
+            object.command,
+            object.hasDefinedMatchers,
+            object.runOptions,
+            object.configurationProperties
+        ));
+    }
+}
+class ConfiguringTask extends CommonTask {
+    constructor(id, source, label, type, configures, runOptions, configurationProperties) {
+        super(id, label, type, runOptions, configurationProperties, source);
+        this._source = source;
+        this.configures = configures;
+    }
+    static is(value) {
+        return value instanceof ConfiguringTask;
+    }
+    fromObject(object) {
+        return object;
+    }
+    getDefinition() {
+        return this.configures;
+    }
+    getWorkspaceFileName() {
+        return (this._source.config.workspace && this._source.config.workspace.configuration) ? resources.basename(this._source.config.workspace.configuration) : undefined;
+    }
+    getWorkspaceFolder() {
+        return this._source.config.workspaceFolder;
+    }
+    getFolderId() {
+        return this._source.kind === TaskSourceKind.User ? USER_TASKS_GROUP_KEY : this._source.config.workspaceFolder?.uri.toString();
+    }
+    getKey() {
+        const workspaceFolder = this.getFolderId();
+        if (!workspaceFolder) {
+            return undefined;
+        }
+        let id = this.configurationProperties.identifier;
+        if (this._source.kind !== TaskSourceKind.Workspace) {
+            id += this._source.kind;
+        }
+        const key = { type: CUSTOMIZED_TASK_TYPE, folder: workspaceFolder, id };
+        return JSON.stringify(key);
+    }
+}
+class ContributedTask extends CommonTask {
+    constructor(id, source, label, type, defines, command, hasDefinedMatchers, runOptions, configurationProperties) {
+        super(id, label, type, runOptions, configurationProperties, source);
+        this.defines = defines;
+        this.hasDefinedMatchers = hasDefinedMatchers;
+        this.command = command;
+        this.icon = configurationProperties.icon;
+        this.hide = configurationProperties.hide;
+    }
+    clone() {
+        return ( new ContributedTask(
+            this._id,
+            this._source,
+            this._label,
+            this.type,
+            this.defines,
+            this.command,
+            this.hasDefinedMatchers,
+            this.runOptions,
+            this.configurationProperties
+        ));
+    }
+    getDefinition() {
+        return this.defines;
+    }
+    static is(value) {
+        return value instanceof ContributedTask;
+    }
+    getMapKey() {
+        const workspaceFolder = this._source.workspaceFolder;
+        return workspaceFolder
+            ? `${( this._source.scope.toString())}|${( workspaceFolder.uri.toString())}|${this._id}|${this.instance}`
+            : `${( this._source.scope.toString())}|${this._id}|${this.instance}`;
+    }
+    getFolderId() {
+        if (this._source.scope === 3  && this._source.workspaceFolder) {
+            return ( this._source.workspaceFolder.uri.toString());
+        }
+        return undefined;
+    }
+    getKey() {
+        const key = { type: 'contributed', scope: this._source.scope, id: this._id };
+        key.folder = this.getFolderId();
+        return JSON.stringify(key);
+    }
+    getWorkspaceFolder() {
+        return this._source.workspaceFolder;
+    }
+    getTelemetryKind() {
+        return 'extension';
+    }
+    fromObject(object) {
+        return ( new ContributedTask(
+            object._id,
+            object._source,
+            object._label,
+            object.type,
+            object.defines,
+            object.command,
+            object.hasDefinedMatchers,
+            object.runOptions,
+            object.configurationProperties
+        ));
+    }
+}
+class InMemoryTask extends CommonTask {
+    constructor(id, source, label, type, runOptions, configurationProperties) {
+        super(id, label, type, runOptions, configurationProperties, source);
+        this._source = source;
+    }
+    clone() {
+        return ( new InMemoryTask(
+            this._id,
+            this._source,
+            this._label,
+            this.type,
+            this.runOptions,
+            this.configurationProperties
+        ));
+    }
+    static is(value) {
+        return value instanceof InMemoryTask;
+    }
+    getTelemetryKind() {
+        return 'composite';
+    }
+    getMapKey() {
+        return `${this._id}|${this.instance}`;
+    }
+    getFolderId() {
+        return undefined;
+    }
+    fromObject(object) {
+        return ( new InMemoryTask(
+            object._id,
+            object._source,
+            object._label,
+            object.type,
+            object.runOptions,
+            object.configurationProperties
+        ));
+    }
+}
+var ExecutionEngine;
+( (function(ExecutionEngine) {
+    ExecutionEngine[ExecutionEngine["Process"] = 1] = "Process";
+    ExecutionEngine[ExecutionEngine["Terminal"] = 2] = "Terminal";
+})(ExecutionEngine || (ExecutionEngine = {})));
+( (function(ExecutionEngine) {
+    ExecutionEngine._default = ExecutionEngine.Terminal;
+})(ExecutionEngine || (ExecutionEngine = {})));
+class TaskSorter {
+    constructor(workspaceFolders) {
+        this._order = ( new Map());
+        for (let i = 0; i < workspaceFolders.length; i++) {
+            this._order.set(( workspaceFolders[i].uri.toString()), i);
+        }
+    }
+    compare(a, b) {
+        const aw = a.getWorkspaceFolder();
+        const bw = b.getWorkspaceFolder();
+        if (aw && bw) {
+            let ai = this._order.get(( aw.uri.toString()));
+            ai = ai === undefined ? 0 : ai + 1;
+            let bi = this._order.get(( bw.uri.toString()));
+            bi = bi === undefined ? 0 : bi + 1;
+            if (ai === bi) {
+                return a._label.localeCompare(b._label);
+            }
+            else {
+                return ai - bi;
+            }
+        }
+        else if (!aw && bw) {
+            return -1;
+        }
+        else if (aw && !bw) {
+            return +1;
+        }
+        else {
+            return 0;
+        }
+    }
+}
+var TaskEvent;
+( (function(TaskEvent) {
+    function common(task) {
+        return {
+            taskId: task._id,
+            taskName: task.configurationProperties.name,
+            runType: task.configurationProperties.isBackground ? "background"  : "singleRun" ,
+            group: task.configurationProperties.group,
+            __task: task,
+        };
+    }
+    function start(task, terminalId, resolvedVariables) {
+        return {
+            ...common(task),
+            kind: "start" ,
+            terminalId,
+            resolvedVariables,
+        };
+    }
+    TaskEvent.start = start;
+    function processStarted(task, terminalId, processId) {
+        return {
+            ...common(task),
+            kind: "processStarted" ,
+            terminalId,
+            processId,
+        };
+    }
+    TaskEvent.processStarted = processStarted;
+    function processEnded(task, terminalId, exitCode) {
+        return {
+            ...common(task),
+            kind: "processEnded" ,
+            terminalId,
+            exitCode,
+        };
+    }
+    TaskEvent.processEnded = processEnded;
+    function terminated(task, terminalId, exitReason) {
+        return {
+            ...common(task),
+            kind: "terminated" ,
+            exitReason,
+            terminalId,
+        };
+    }
+    TaskEvent.terminated = terminated;
+    function general(kind, task, terminalId) {
+        return {
+            ...common(task),
+            kind,
+            terminalId,
+        };
+    }
+    TaskEvent.general = general;
+    function changed() {
+        return { kind: "changed"  };
+    }
+    TaskEvent.changed = changed;
+})(TaskEvent || (TaskEvent = {})));
+var KeyedTaskIdentifier;
+( (function(KeyedTaskIdentifier) {
+    function sortedStringify(literal) {
+        const keys = ( Object.keys(literal)).sort();
+        let result = '';
+        for (const key of keys) {
+            let stringified = literal[key];
+            if (stringified instanceof Object) {
+                stringified = sortedStringify(stringified);
+            }
+            else if (typeof stringified === 'string') {
+                stringified = stringified.replace(/,/g, ',,');
+            }
+            result += key + ',' + stringified + ',';
+        }
+        return result;
+    }
+    function create(value) {
+        const resultKey = sortedStringify(value);
+        const result = { _key: resultKey, type: value.taskType };
+        Object.assign(result, value);
+        return result;
+    }
+    KeyedTaskIdentifier.create = create;
+})(KeyedTaskIdentifier || (KeyedTaskIdentifier = {})));
+var TaskDefinition;
+( (function(TaskDefinition) {
+    function createTaskIdentifier(external, reporter) {
+        const definition = TaskDefinitionRegistry.get(external.type);
+        if (definition === undefined) {
+            const copy = Objects.deepClone(external);
+            delete copy._key;
+            return KeyedTaskIdentifier.create(copy);
+        }
+        const literal = Object.create(null);
+        literal.type = definition.taskType;
+        const required = ( new Set());
+        definition.required.forEach(element => required.add(element));
+        const properties = definition.properties;
+        for (const property of ( Object.keys(properties))) {
+            const value = external[property];
+            if (value !== undefined && value !== null) {
+                literal[property] = value;
+            }
+            else if (( required.has(property))) {
+                const schema = properties[property];
+                if (schema.default !== undefined) {
+                    literal[property] = Objects.deepClone(schema.default);
+                }
+                else {
+                    switch (schema.type) {
+                        case 'boolean':
+                            literal[property] = false;
+                            break;
+                        case 'number':
+                        case 'integer':
+                            literal[property] = 0;
+                            break;
+                        case 'string':
+                            literal[property] = '';
+                            break;
+                        default:
+                            reporter.error(( nls.localizeWithPath(
+                                'vs/workbench/contrib/tasks/common/tasks',
+                                'TaskDefinition.missingRequiredProperty',
+                                'Error: the task identifier \'{0}\' is missing the required property \'{1}\'. The task identifier will be ignored.',
+                                JSON.stringify(external, undefined, 0),
+                                property
+                            )));
+                            return undefined;
+                    }
+                }
+            }
+        }
+        return KeyedTaskIdentifier.create(literal);
+    }
+    TaskDefinition.createTaskIdentifier = createTaskIdentifier;
+})(TaskDefinition || (TaskDefinition = {})));
+export { CUSTOMIZED_TASK_TYPE, CommandOptions, CommandString, CommonTask, ConfiguringTask, ContributedTask, CustomTask, ExecutionEngine, InMemoryTask, KeyedTaskIdentifier, PanelKind, PresentationOptions, RevealKind, RevealProblemKind, RunOnOptions, RunOptions, RuntimeType, ShellQuoting, TASKS_CATEGORY, TASK_RUNNING_STATE, TaskDefinition, TaskEvent, TaskGroup, TaskSorter, TaskSourceKind, USER_TASKS_GROUP_KEY };