@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/tasks/browser/task.contribution.js

@@ -0,0 +1,682 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { registerAction2, MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
+import { ProblemMatcherRegistry } from '../common/problemMatcher.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { Extensions as Extensions$3 } from '../../../../platform/jsonschemas/common/jsonContributionRegistry.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+import { Extensions as Extensions$1 } from '../../../services/output/common/output.js';
+import { TASKS_CATEGORY, TASK_RUNNING_STATE, TaskGroup } from '../common/tasks.js';
+import { TaskExecutionSupportedContext, TaskCommandsRegistered, ITaskService } from '../common/taskService.js';
+import { Extensions } from '../../../common/contributions.js';
+import { RunAutomaticTasks, ManageAutomaticTaskRunning } from './runAutomaticTasks.js';
+import { KeybindingsRegistry } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import schema$1 from '../common/jsonSchema_v1.js';
+import schema$2, { updateProblemMatchers, updateTaskDefinitions } from '../common/jsonSchema_v2.js';
+import { ConfigureTaskAction, AbstractTaskService } from './abstractTaskService.js';
+import { tasksSchemaId } from '../../../services/configuration/common/configuration.js';
+import { Extensions as Extensions$4 } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { WorkbenchStateContext } from '../../../common/contextkeys.js';
+import { Extensions as Extensions$2 } from '../../../../platform/quickinput/common/quickAccess.js';
+import { TasksQuickAccessProvider } from './tasksQuickAccess.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { TaskDefinitionRegistry } from '../common/taskDefinitionRegistry.js';
+import { isString } from '../../../../base/common/types.js';
+import { promiseWithResolvers } from '../../../../base/common/async.js';
+const workbenchRegistry = ( Registry.as(Extensions.Workbench));
+workbenchRegistry.registerWorkbenchContribution(RunAutomaticTasks, 4 );
+registerAction2(ManageAutomaticTaskRunning);
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: ManageAutomaticTaskRunning.ID,
+        title: ManageAutomaticTaskRunning.LABEL,
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+let TaskStatusBarContributions = class TaskStatusBarContributions extends Disposable {
+    constructor(_taskService, _statusbarService, _progressService) {
+        super();
+        this._taskService = _taskService;
+        this._statusbarService = _statusbarService;
+        this._progressService = _progressService;
+        this._activeTasksCount = 0;
+        this._registerListeners();
+    }
+    _registerListeners() {
+        let promise = undefined;
+        let resolve;
+        this._taskService.onDidStateChange(event => {
+            if (event.kind === "changed" ) {
+                this._updateRunningTasksStatus();
+            }
+            if (!this._ignoreEventForUpdateRunningTasksCount(event)) {
+                switch (event.kind) {
+                    case "active" :
+                        this._activeTasksCount++;
+                        if (this._activeTasksCount === 1) {
+                            if (!promise) {
+                                ({ promise, resolve } = promiseWithResolvers());
+                            }
+                        }
+                        break;
+                    case "inactive" :
+                        if (this._activeTasksCount > 0) {
+                            this._activeTasksCount--;
+                            if (this._activeTasksCount === 0) {
+                                if (promise && resolve) {
+                                    resolve();
+                                }
+                            }
+                        }
+                        break;
+                    case "terminated" :
+                        if (this._activeTasksCount !== 0) {
+                            this._activeTasksCount = 0;
+                            if (promise && resolve) {
+                                resolve();
+                            }
+                        }
+                        break;
+                }
+            }
+            if (promise && ((event.kind === "active") ) && (this._activeTasksCount === 1)) {
+                this._progressService.withProgress({ location: 10 , command: 'workbench.action.tasks.showTasks', type: 'loading' }, progress => {
+                    progress.report({ message: ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/task.contribution',
+                        'building',
+                        'Building...'
+                    )) });
+                    return promise;
+                }).then(() => {
+                    promise = undefined;
+                });
+            }
+        });
+    }
+    async _updateRunningTasksStatus() {
+        const tasks = await this._taskService.getActiveTasks();
+        if (tasks.length === 0) {
+            if (this._runningTasksStatusItem) {
+                this._runningTasksStatusItem.dispose();
+                this._runningTasksStatusItem = undefined;
+            }
+        }
+        else {
+            const itemProps = {
+                name: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'status.runningTasks',
+                    "Running Tasks"
+                )),
+                text: `$(tools) ${tasks.length}`,
+                ariaLabel: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'numberOfRunningTasks',
+                    "{0} running tasks",
+                    tasks.length
+                )),
+                tooltip: ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'runningTasks',
+                    "Show Running Tasks"
+                )),
+                command: 'workbench.action.tasks.showTasks',
+            };
+            if (!this._runningTasksStatusItem) {
+                this._runningTasksStatusItem = this._statusbarService.addEntry(itemProps, 'status.runningTasks', 0 , 49 );
+            }
+            else {
+                this._runningTasksStatusItem.update(itemProps);
+            }
+        }
+    }
+    _ignoreEventForUpdateRunningTasksCount(event) {
+        if (!this._taskService.inTerminal() || event.kind === "changed" ) {
+            return false;
+        }
+        if ((isString(event.group) ? event.group : event.group?._id) !== TaskGroup.Build._id) {
+            return true;
+        }
+        return event.__task.configurationProperties.problemMatchers === undefined || event.__task.configurationProperties.problemMatchers.length === 0;
+    }
+};
+TaskStatusBarContributions = ( __decorate([
+    ( __param(0, ITaskService)),
+    ( __param(1, IStatusbarService)),
+    ( __param(2, IProgressService))
+], TaskStatusBarContributions));
+workbenchRegistry.registerWorkbenchContribution(TaskStatusBarContributions, 3 );
+MenuRegistry.appendMenuItem(MenuId.MenubarTerminalMenu, {
+    group: "3_run" ,
+    command: {
+        id: 'workbench.action.tasks.runTask',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            { key: 'miRunTask', comment: ['&& denotes a mnemonic'] },
+            "&&Run Task..."
+        ))
+    },
+    order: 1,
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarTerminalMenu, {
+    group: "3_run" ,
+    command: {
+        id: 'workbench.action.tasks.build',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            { key: 'miBuildTask', comment: ['&& denotes a mnemonic'] },
+            "Run &&Build Task..."
+        ))
+    },
+    order: 2,
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarTerminalMenu, {
+    group: "5_manage" ,
+    command: {
+        precondition: TASK_RUNNING_STATE,
+        id: 'workbench.action.tasks.showTasks',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            { key: 'miRunningTask', comment: ['&& denotes a mnemonic'] },
+            "Show Runnin&&g Tasks..."
+        ))
+    },
+    order: 1,
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarTerminalMenu, {
+    group: "5_manage" ,
+    command: {
+        precondition: TASK_RUNNING_STATE,
+        id: 'workbench.action.tasks.restartTask',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            { key: 'miRestartTask', comment: ['&& denotes a mnemonic'] },
+            "R&&estart Running Task..."
+        ))
+    },
+    order: 2,
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarTerminalMenu, {
+    group: "5_manage" ,
+    command: {
+        precondition: TASK_RUNNING_STATE,
+        id: 'workbench.action.tasks.terminate',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            { key: 'miTerminateTask', comment: ['&& denotes a mnemonic'] },
+            "&&Terminate Task..."
+        ))
+    },
+    order: 3,
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarTerminalMenu, {
+    group: "7_configure" ,
+    command: {
+        id: 'workbench.action.tasks.configureTaskRunner',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            { key: 'miConfigureTask', comment: ['&& denotes a mnemonic'] },
+            "&&Configure Tasks..."
+        ))
+    },
+    order: 1,
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarTerminalMenu, {
+    group: "7_configure" ,
+    command: {
+        id: 'workbench.action.tasks.configureDefaultBuildTask',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            { key: 'miConfigureBuildTask', comment: ['&& denotes a mnemonic'] },
+            "Configure De&&fault Build Task..."
+        ))
+    },
+    order: 2,
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.openWorkspaceFileTasks',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'workbench.action.tasks.openWorkspaceFileTasks',
+            "Open Workspace Tasks"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('workspace')), TaskExecutionSupportedContext))
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: ConfigureTaskAction.ID,
+        title: ConfigureTaskAction.TEXT,
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.showLog',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'ShowLogAction.label',
+            "Show Task Log"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.runTask',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'RunTaskAction.label',
+            "Run Task"
+        )),
+        category: TASKS_CATEGORY
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.reRunTask',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'ReRunTaskAction.label',
+            "Rerun Last Task"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.restartTask',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'RestartTaskAction.label',
+            "Restart Running Task"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.showTasks',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'ShowTasksAction.label',
+            "Show Running Tasks"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.terminate',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'TerminateAction.label',
+            "Terminate Task"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.build',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'BuildAction.label',
+            "Run Build Task"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.test',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'TestAction.label',
+            "Run Test Task"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.configureDefaultBuildTask',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'ConfigureDefaultBuildTask.label',
+            "Configure Default Build Task"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.configureDefaultTestTask',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'ConfigureDefaultTestTask.label',
+            "Configure Default Test Task"
+        )),
+        category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: 'workbench.action.tasks.openUserTasks',
+        title: ( localize2WithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'workbench.action.tasks.openUserTasks',
+            "Open User Tasks"
+        )), category: TASKS_CATEGORY
+    },
+    when: TaskExecutionSupportedContext
+});
+class UserTasksGlobalActionContribution extends Disposable {
+    constructor() {
+        super();
+        this.registerActions();
+    }
+    registerActions() {
+        const id = 'workbench.action.tasks.openUserTasks';
+        const title = ( localizeWithPath(
+            'vs/workbench/contrib/tasks/browser/task.contribution',
+            'userTasks',
+            "User Tasks"
+        ));
+        this._register(MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
+            command: {
+                id,
+                title
+            },
+            when: TaskExecutionSupportedContext,
+            group: '2_configuration',
+            order: 6
+        }));
+        this._register(MenuRegistry.appendMenuItem(MenuId.MenubarPreferencesMenu, {
+            command: {
+                id,
+                title
+            },
+            when: TaskExecutionSupportedContext,
+            group: '2_configuration',
+            order: 6
+        }));
+    }
+}
+workbenchRegistry.registerWorkbenchContribution(UserTasksGlobalActionContribution, 3 );
+KeybindingsRegistry.registerKeybindingRule({
+    id: 'workbench.action.tasks.build',
+    weight: 200 ,
+    when: TaskCommandsRegistered,
+    primary: 2048  | 1024  | 32
+});
+const outputChannelRegistry = ( Registry.as(Extensions$1.OutputChannels));
+outputChannelRegistry.registerChannel({ id: AbstractTaskService.OutputChannelId, label: AbstractTaskService.OutputChannelLabel, log: false });
+const quickAccessRegistry = (( Registry.as(Extensions$2.Quickaccess)));
+const tasksPickerContextKey = 'inTasksPicker';
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: TasksQuickAccessProvider,
+    prefix: TasksQuickAccessProvider.PREFIX,
+    contextKey: tasksPickerContextKey,
+    placeholder: ( localizeWithPath(
+        'vs/workbench/contrib/tasks/browser/task.contribution',
+        'tasksQuickAccessPlaceholder',
+        "Type the name of a task to run."
+    )),
+    helpEntries: [{ description: ( localizeWithPath(
+        'vs/workbench/contrib/tasks/browser/task.contribution',
+        'tasksQuickAccessHelp',
+        "Run Task"
+    )), commandCenterOrder: 60 }]
+});
+const schema = {
+    id: tasksSchemaId,
+    description: 'Task definition file',
+    type: 'object',
+    allowTrailingCommas: true,
+    allowComments: true,
+    default: {
+        version: '2.0.0',
+        tasks: [
+            {
+                label: 'My Task',
+                command: 'echo hello',
+                type: 'shell',
+                args: [],
+                problemMatcher: ['$tsc'],
+                presentation: {
+                    reveal: 'always'
+                },
+                group: 'build'
+            }
+        ]
+    }
+};
+schema.definitions = {
+    ...schema$1.definitions,
+    ...schema$2.definitions,
+};
+schema.oneOf = [...(schema$2.oneOf || []), ...(schema$1.oneOf || [])];
+const jsonRegistry = ( Registry.as(Extensions$3.JSONContribution));
+jsonRegistry.registerSchema(tasksSchemaId, schema);
+ProblemMatcherRegistry.onMatcherChanged(() => {
+    updateProblemMatchers();
+    jsonRegistry.notifySchemaChanged(tasksSchemaId);
+});
+TaskDefinitionRegistry.onDefinitionsChanged(() => {
+    updateTaskDefinitions();
+    jsonRegistry.notifySchemaChanged(tasksSchemaId);
+});
+const configurationRegistry = ( Registry.as(Extensions$4.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'task',
+    order: 100,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/tasks/browser/task.contribution',
+        'tasksConfigurationTitle',
+        "Tasks"
+    )),
+    type: 'object',
+    properties: {
+        ["task.problemMatchers.neverPrompt" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.problemMatchers.neverPrompt',
+                "Configures whether to show the problem matcher prompt when running a task. Set to `true` to never prompt, or use a dictionary of task types to turn off prompting only for specific task types."
+            )),
+            'oneOf': [
+                {
+                    type: 'boolean',
+                    markdownDescription: ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/task.contribution',
+                        'task.problemMatchers.neverPrompt.boolean',
+                        'Sets problem matcher prompting behavior for all tasks.'
+                    ))
+                },
+                {
+                    type: 'object',
+                    patternProperties: {
+                        '.*': {
+                            type: 'boolean'
+                        }
+                    },
+                    markdownDescription: ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/task.contribution',
+                        'task.problemMatchers.neverPrompt.array',
+                        'An object containing task type-boolean pairs to never prompt for problem matchers on.'
+                    )),
+                    default: {
+                        'shell': true
+                    }
+                }
+            ],
+            default: false
+        },
+        ["task.autoDetect" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.autoDetect',
+                "Controls enablement of `provideTasks` for all task provider extension. If the Tasks: Run Task command is slow, disabling auto detect for task providers may help. Individual extensions may also provide settings that disable auto detection."
+            )),
+            type: 'string',
+            enum: ['on', 'off'],
+            default: 'on'
+        },
+        ["task.slowProviderWarning" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.slowProviderWarning',
+                "Configures whether a warning is shown when a provider is slow"
+            )),
+            'oneOf': [
+                {
+                    type: 'boolean',
+                    markdownDescription: ( localizeWithPath(
+                        'vs/workbench/contrib/tasks/browser/task.contribution',
+                        'task.slowProviderWarning.boolean',
+                        'Sets the slow provider warning for all tasks.'
+                    ))
+                },
+                {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        markdownDescription: ( localizeWithPath(
+                            'vs/workbench/contrib/tasks/browser/task.contribution',
+                            'task.slowProviderWarning.array',
+                            'An array of task types to never show the slow provider warning.'
+                        ))
+                    }
+                }
+            ],
+            default: true
+        },
+        ["task.quickOpen.history" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.quickOpen.history',
+                "Controls the number of recent items tracked in task quick open dialog."
+            )),
+            type: 'number',
+            default: 30, minimum: 0, maximum: 30
+        },
+        ["task.quickOpen.detail" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.quickOpen.detail',
+                "Controls whether to show the task detail for tasks that have a detail in task quick picks, such as Run Task."
+            )),
+            type: 'boolean',
+            default: true
+        },
+        ["task.quickOpen.skip" ]: {
+            type: 'boolean',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.quickOpen.skip',
+                "Controls whether the task quick pick is skipped when there is only one task to pick from."
+            )),
+            default: false
+        },
+        ["task.quickOpen.showAll" ]: {
+            type: 'boolean',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.quickOpen.showAll',
+                "Causes the Tasks: Run Task command to use the slower \"show all\" behavior instead of the faster two level picker where tasks are grouped by provider."
+            )),
+            default: false
+        },
+        ["task.allowAutomaticTasks" ]: {
+            type: 'string',
+            enum: ['on', 'off'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'task.allowAutomaticTasks.on',
+                    "Always"
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'task.allowAutomaticTasks.off',
+                    "Never"
+                )),
+            ],
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.allowAutomaticTasks',
+                "Enable automatic tasks - note that tasks won't run in an untrusted workspace."
+            )),
+            default: 'on',
+            restricted: true
+        },
+        ["task.reconnection" ]: {
+            type: 'boolean',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.reconnection',
+                "On window reload, reconnect to tasks that have problem matchers."
+            )),
+            default: true
+        },
+        ["task.saveBeforeRun" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.saveBeforeRun',
+                'Save all dirty editors before running a task.'
+            )),
+            type: 'string',
+            enum: ['always', 'never', 'prompt'],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'task.saveBeforeRun.always',
+                    'Always saves all editors before running.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'task.saveBeforeRun.never',
+                    'Never saves editors before running.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/tasks/browser/task.contribution',
+                    'task.SaveBeforeRun.prompt',
+                    'Prompts whether to save editors before running.'
+                )),
+            ],
+            default: 'always',
+        },
+        ["task.verboseLogging" ]: {
+            type: 'boolean',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/tasks/browser/task.contribution',
+                'task.verboseLogging',
+                "Enable verbose logging for tasks."
+            )),
+            default: false
+        },
+    }
+});
+export { TaskStatusBarContributions };