@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/debug/browser/debugSessionPicker.js

@@ -0,0 +1,106 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IDebugService, REPL_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+
+async function showDebugSessionMenu(accessor, selectAndStartID) {
+    const quickInputService = accessor.get(IQuickInputService);
+    const debugService = accessor.get(IDebugService);
+    const viewsService = accessor.get(IViewsService);
+    const commandService = accessor.get(ICommandService);
+    const localDisposableStore = ( new DisposableStore());
+    const quickPick = quickInputService.createQuickPick();
+    localDisposableStore.add(quickPick);
+    quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
+    quickPick.placeholder = ( nls.localize('moveFocusedView.selectView', 'Search debug sessions by name'));
+    const pickItems = _getPicksAndActiveItem(quickPick.value, selectAndStartID, debugService, viewsService, commandService);
+    quickPick.items = pickItems.picks;
+    quickPick.activeItems = pickItems.activeItems;
+    localDisposableStore.add(quickPick.onDidChangeValue(async () => {
+        quickPick.items = _getPicksAndActiveItem(quickPick.value, selectAndStartID, debugService, viewsService, commandService).picks;
+    }));
+    localDisposableStore.add(quickPick.onDidAccept(() => {
+        const selectedItem = quickPick.selectedItems[0];
+        selectedItem.accept();
+        quickPick.hide();
+        localDisposableStore.dispose();
+    }));
+    quickPick.show();
+}
+function _getPicksAndActiveItem(filter, selectAndStartID, debugService, viewsService, commandService) {
+    const debugConsolePicks = [];
+    const headerSessions = [];
+    const currSession = debugService.getViewModel().focusedSession;
+    const sessions = debugService.getModel().getSessions(false);
+    const activeItems = [];
+    sessions.forEach((session) => {
+        if (session.compact && session.parentSession) {
+            headerSessions.push(session.parentSession);
+        }
+    });
+    sessions.forEach((session) => {
+        const isHeader = headerSessions.includes(session);
+        if (!session.parentSession) {
+            debugConsolePicks.push({ type: 'separator', label: isHeader ? session.name : undefined });
+        }
+        if (!isHeader) {
+            const pick = _createPick(session, filter, debugService, viewsService);
+            if (pick) {
+                debugConsolePicks.push(pick);
+                if (session.getId() === currSession?.getId()) {
+                    activeItems.push(pick);
+                }
+            }
+        }
+    });
+    if (debugConsolePicks.length) {
+        debugConsolePicks.push({ type: 'separator' });
+    }
+    const createDebugSessionLabel = ( nls.localize('workbench.action.debug.startDebug', 'Start a New Debug Session'));
+    debugConsolePicks.push({
+        label: `$(plus) ${createDebugSessionLabel}`,
+        ariaLabel: createDebugSessionLabel,
+        accept: () => commandService.executeCommand(selectAndStartID)
+    });
+    return { picks: debugConsolePicks, activeItems };
+}
+function _getSessionInfo(session) {
+    const label = (!session.configuration.name.length) ? session.name : session.configuration.name;
+    const parentName = session.compact ? undefined : session.parentSession?.configuration.name;
+    let description = '';
+    let ariaLabel = '';
+    if (parentName) {
+        ariaLabel = ( nls.localize(
+            'workbench.action.debug.spawnFrom',
+            'Session {0} spawned from {1}',
+            label,
+            parentName
+        ));
+        description = parentName;
+    }
+    return { label, description, ariaLabel };
+}
+function _createPick(session, filter, debugService, viewsService, commandService) {
+    const pickInfo = _getSessionInfo(session);
+    const highlights = matchesFuzzy(filter, pickInfo.label, true);
+    if (highlights) {
+        return {
+            label: pickInfo.label,
+            description: pickInfo.description,
+            ariaLabel: pickInfo.ariaLabel,
+            highlights: { label: highlights },
+            accept: () => {
+                debugService.focusStackFrame(undefined, undefined, session, { explicit: true });
+                if (!viewsService.isViewVisible(REPL_VIEW_ID)) {
+                    viewsService.openView(REPL_VIEW_ID, true);
+                }
+            }
+        };
+    }
+    return undefined;
+}
+
+export { showDebugSessionMenu };

package/vscode/src/vs/workbench/contrib/debug/browser/debugStatus.js

@@ -0,0 +1,68 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
+
+let DebugStatusContribution = class DebugStatusContribution {
+    constructor(statusBarService, debugService, configurationService) {
+        this.statusBarService = statusBarService;
+        this.debugService = debugService;
+        this.toDispose = [];
+        const addStatusBarEntry = () => {
+            this.entryAccessor = this.statusBarService.addEntry(this.entry, 'status.debug', 0 , 30 );
+        };
+        const setShowInStatusBar = () => {
+            this.showInStatusBar = configurationService.getValue('debug').showInStatusBar;
+            if (this.showInStatusBar === 'always' && !this.entryAccessor) {
+                addStatusBarEntry();
+            }
+        };
+        setShowInStatusBar();
+        this.toDispose.push(this.debugService.onDidChangeState(state => {
+            if (state !== 0  && this.showInStatusBar === 'onFirstSessionStart' && !this.entryAccessor) {
+                addStatusBarEntry();
+            }
+        }));
+        this.toDispose.push(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.showInStatusBar')) {
+                setShowInStatusBar();
+                if (this.entryAccessor && this.showInStatusBar === 'never') {
+                    this.entryAccessor.dispose();
+                    this.entryAccessor = undefined;
+                }
+            }
+        }));
+        this.toDispose.push(this.debugService.getConfigurationManager().onDidSelectConfiguration(e => {
+            this.entryAccessor?.update(this.entry);
+        }));
+    }
+    get entry() {
+        let text = '';
+        const manager = this.debugService.getConfigurationManager();
+        const name = manager.selectedConfiguration.name || '';
+        const nameAndLaunchPresent = name && manager.selectedConfiguration.launch;
+        if (nameAndLaunchPresent) {
+            text = (manager.getLaunches().length > 1 ? `${name} (${manager.selectedConfiguration.launch.name})` : name);
+        }
+        return {
+            name: ( nls.localize('status.debug', "Debug")),
+            text: '$(debug-alt-small) ' + text,
+            ariaLabel: ( nls.localize('debugTarget', "Debug: {0}", text)),
+            tooltip: ( nls.localize('selectAndStartDebug', "Select and start debug configuration")),
+            command: 'workbench.action.debug.selectandstart'
+        };
+    }
+    dispose() {
+        this.entryAccessor?.dispose();
+        dispose(this.toDispose);
+    }
+};
+DebugStatusContribution = ( __decorate([
+    ( __param(0, IStatusbarService)),
+    ( __param(1, IDebugService)),
+    ( __param(2, IConfigurationService))
+], DebugStatusContribution));
+
+export { DebugStatusContribution };

package/vscode/src/vs/workbench/contrib/debug/browser/debugTaskRunner.js

@@ -0,0 +1,275 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { Markers } from 'vscode/vscode/vs/workbench/contrib/markers/common/markers';
+import { ITaskService } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskService';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { MarkerSeverity, IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { createErrorWithActions } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { DEBUG_CONFIGURE_COMMAND_ID, DEBUG_CONFIGURE_LABEL } from './debugCommands.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+function once(match, event) {
+    return (listener, thisArgs = null, disposables) => {
+        const result = event(e => {
+            if (match(e)) {
+                result.dispose();
+                return listener.call(thisArgs, e);
+            }
+        }, null, disposables);
+        return result;
+    };
+}
+const DEBUG_TASK_ERROR_CHOICE_KEY = 'debug.taskerrorchoice';
+let DebugTaskRunner = class DebugTaskRunner {
+    constructor(taskService, markerService, configurationService, viewsService, dialogService, storageService, commandService) {
+        this.taskService = taskService;
+        this.markerService = markerService;
+        this.configurationService = configurationService;
+        this.viewsService = viewsService;
+        this.dialogService = dialogService;
+        this.storageService = storageService;
+        this.commandService = commandService;
+        this.canceled = false;
+    }
+    cancel() {
+        this.canceled = true;
+    }
+    async runTaskAndCheckErrors(root, taskId) {
+        try {
+            this.canceled = false;
+            const taskSummary = await this.runTask(root, taskId);
+            if (this.canceled || (taskSummary && taskSummary.exitCode === undefined)) {
+                return 0 ;
+            }
+            const errorCount = taskId ? this.markerService.read({ severities: MarkerSeverity.Error, take: 2 }).length : 0;
+            const successExitCode = taskSummary && taskSummary.exitCode === 0;
+            const failureExitCode = taskSummary && taskSummary.exitCode !== 0;
+            const onTaskErrors = this.configurationService.getValue('debug').onTaskErrors;
+            if (successExitCode || onTaskErrors === 'debugAnyway' || (errorCount === 0 && !failureExitCode)) {
+                return 1 ;
+            }
+            if (onTaskErrors === 'showErrors') {
+                await this.viewsService.openView(Markers.MARKERS_VIEW_ID, true);
+                return Promise.resolve(0 );
+            }
+            if (onTaskErrors === 'abort') {
+                return Promise.resolve(0 );
+            }
+            const taskLabel = typeof taskId === 'string' ? taskId : taskId ? taskId.name : '';
+            const message = errorCount > 1
+                ? ( nls.localize(
+                'preLaunchTaskErrors',
+                "Errors exist after running preLaunchTask '{0}'.",
+                taskLabel
+            ))
+                : errorCount === 1
+                    ? ( nls.localize(
+                'preLaunchTaskError',
+                "Error exists after running preLaunchTask '{0}'.",
+                taskLabel
+            ))
+                    : taskSummary && typeof taskSummary.exitCode === 'number'
+                        ? ( nls.localize(
+                'preLaunchTaskExitCode',
+                "The preLaunchTask '{0}' terminated with exit code {1}.",
+                taskLabel,
+                taskSummary.exitCode
+            ))
+                        : ( nls.localize(
+                'preLaunchTaskTerminated',
+                "The preLaunchTask '{0}' terminated.",
+                taskLabel
+            ));
+            let DebugChoice;
+            ( (function(DebugChoice) {
+                DebugChoice[DebugChoice["DebugAnyway"] = 1] = "DebugAnyway";
+                DebugChoice[DebugChoice["ShowErrors"] = 2] = "ShowErrors";
+                DebugChoice[DebugChoice["Cancel"] = 0] = "Cancel";
+            })(DebugChoice || (DebugChoice = {})));
+            const { result, checkboxChecked } = await this.dialogService.prompt({
+                type: Severity.Warning,
+                message,
+                buttons: [
+                    {
+                        label: ( nls.localize(
+                            { key: 'debugAnyway', comment: ['&& denotes a mnemonic'] },
+                            "&&Debug Anyway"
+                        )),
+                        run: () => DebugChoice.DebugAnyway
+                    },
+                    {
+                        label: ( nls.localize({ key: 'showErrors', comment: ['&& denotes a mnemonic'] }, "&&Show Errors")),
+                        run: () => DebugChoice.ShowErrors
+                    }
+                ],
+                cancelButton: {
+                    label: ( nls.localize('abort', "Abort")),
+                    run: () => DebugChoice.Cancel
+                },
+                checkbox: {
+                    label: ( nls.localize('remember', "Remember my choice in user settings")),
+                }
+            });
+            const debugAnyway = result === DebugChoice.DebugAnyway;
+            const abort = result === DebugChoice.Cancel;
+            if (checkboxChecked) {
+                this.configurationService.updateValue('debug.onTaskErrors', result === DebugChoice.DebugAnyway ? 'debugAnyway' : abort ? 'abort' : 'showErrors');
+            }
+            if (abort) {
+                return Promise.resolve(0 );
+            }
+            if (debugAnyway) {
+                return 1 ;
+            }
+            await this.viewsService.openView(Markers.MARKERS_VIEW_ID, true);
+            return Promise.resolve(0 );
+        }
+        catch (err) {
+            const taskConfigureAction = this.taskService.configureAction();
+            const choiceMap = JSON.parse(this.storageService.get(DEBUG_TASK_ERROR_CHOICE_KEY, 1 , '{}'));
+            let choice = -1;
+            let DebugChoice;
+            ( (function(DebugChoice) {
+                DebugChoice[DebugChoice["DebugAnyway"] = 0] = "DebugAnyway";
+                DebugChoice[DebugChoice["ConfigureTask"] = 1] = "ConfigureTask";
+                DebugChoice[DebugChoice["Cancel"] = 2] = "Cancel";
+            })(DebugChoice || (DebugChoice = {})));
+            if (choiceMap[err.message] !== undefined) {
+                choice = choiceMap[err.message];
+            }
+            else {
+                const { result, checkboxChecked } = await this.dialogService.prompt({
+                    type: Severity.Error,
+                    message: err.message,
+                    buttons: [
+                        {
+                            label: ( nls.localize(
+                                { key: 'debugAnyway', comment: ['&& denotes a mnemonic'] },
+                                "&&Debug Anyway"
+                            )),
+                            run: () => DebugChoice.DebugAnyway
+                        },
+                        {
+                            label: taskConfigureAction.label,
+                            run: () => DebugChoice.ConfigureTask
+                        }
+                    ],
+                    cancelButton: {
+                        run: () => DebugChoice.Cancel
+                    },
+                    checkbox: {
+                        label: ( nls.localize('rememberTask', "Remember my choice for this task"))
+                    }
+                });
+                choice = result;
+                if (checkboxChecked) {
+                    choiceMap[err.message] = choice;
+                    this.storageService.store(DEBUG_TASK_ERROR_CHOICE_KEY, JSON.stringify(choiceMap), 1 , 1 );
+                }
+            }
+            if (choice === DebugChoice.ConfigureTask) {
+                await taskConfigureAction.run();
+            }
+            return choice === DebugChoice.DebugAnyway ? 1  : 0 ;
+        }
+    }
+    async runTask(root, taskId) {
+        if (!taskId) {
+            return Promise.resolve(null);
+        }
+        if (!root) {
+            return Promise.reject(( new Error(( nls.localize(
+                'invalidTaskReference',
+                "Task '{0}' can not be referenced from a launch configuration that is in a different workspace folder.",
+                typeof taskId === 'string' ? taskId : taskId.type
+            )))));
+        }
+        const task = await this.taskService.getTask(root, taskId);
+        if (!task) {
+            const errorMessage = typeof taskId === 'string'
+                ? ( nls.localize('DebugTaskNotFoundWithTaskId', "Could not find the task '{0}'.", taskId))
+                : ( nls.localize('DebugTaskNotFound', "Could not find the specified task."));
+            return Promise.reject(createErrorWithActions(errorMessage, [( new Action(
+                DEBUG_CONFIGURE_COMMAND_ID,
+                DEBUG_CONFIGURE_LABEL,
+                undefined,
+                true,
+                () => this.commandService.executeCommand(DEBUG_CONFIGURE_COMMAND_ID)
+            ))]));
+        }
+        let taskStarted = false;
+        const inactivePromise = ( new Promise((c, e) => once(e => {
+            return (e.kind === "inactive"
+                || (e.kind === "processEnded"  && e.exitCode === undefined))
+                && e.taskId === task._id;
+        }, this.taskService.onDidStateChange)(e => {
+            taskStarted = true;
+            c(e.kind === "processEnded"  ? { exitCode: e.exitCode } : null);
+        })));
+        const promise = this.taskService.getActiveTasks().then(async (tasks) => {
+            if (tasks.find(t => t._id === task._id)) {
+                const busyTasks = await this.taskService.getBusyTasks();
+                if (busyTasks.find(t => t._id === task._id)) {
+                    taskStarted = true;
+                    return inactivePromise;
+                }
+                return Promise.resolve(null);
+            }
+            once(e => (((e.kind === "active") ) || ((e.kind === "dependsOnStarted") )) && e.taskId === task._id, this.taskService.onDidStateChange)(() => {
+                taskStarted = true;
+            });
+            const taskPromise = this.taskService.run(task);
+            if (task.configurationProperties.isBackground) {
+                return inactivePromise;
+            }
+            return taskPromise.then(x => x ?? null);
+        });
+        return ( new Promise((c, e) => {
+            const waitForInput = ( new Promise(
+                resolve => once(e => ((e.kind === "acquiredInput") ) && e.taskId === task._id, this.taskService.onDidStateChange)(() => {
+                    resolve();
+                })
+            ));
+            promise.then(result => {
+                taskStarted = true;
+                c(result);
+            }, error => e(error));
+            waitForInput.then(() => {
+                const waitTime = task.configurationProperties.isBackground ? 5000 : 10000;
+                setTimeout(() => {
+                    if (!taskStarted) {
+                        const errorMessage = typeof taskId === 'string'
+                            ? ( nls.localize(
+                            'taskNotTrackedWithTaskId',
+                            "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.",
+                            taskId
+                        ))
+                            : ( nls.localize(
+                            'taskNotTracked',
+                            "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.",
+                            JSON.stringify(taskId)
+                        ));
+                        e({ severity: Severity.Error, message: errorMessage });
+                    }
+                }, waitTime);
+            });
+        }));
+    }
+};
+DebugTaskRunner = ( __decorate([
+    ( __param(0, ITaskService)),
+    ( __param(1, IMarkerService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IViewsService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, ICommandService))
+], DebugTaskRunner));
+
+export { DebugTaskRunner };