@codingame/monaco-vscode-debug-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,80 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { VIEWLET_ID, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
+
+let DebugProgressContribution = class DebugProgressContribution {
+    constructor(debugService, progressService, viewsService) {
+        this.toDispose = [];
+        let progressListener;
+        const listenOnProgress = (session) => {
+            if (progressListener) {
+                progressListener.dispose();
+                progressListener = undefined;
+            }
+            if (session) {
+                progressListener = session.onDidProgressStart(async (progressStartEvent) => {
+                    const promise = ( new Promise(r => {
+                        const listener = Event.any(Event.filter(session.onDidProgressEnd, e => e.body.progressId === progressStartEvent.body.progressId), session.onDidEndAdapter)(() => {
+                            listener.dispose();
+                            r();
+                        });
+                    }));
+                    if (viewsService.isViewContainerVisible(VIEWLET_ID)) {
+                        progressService.withProgress({ location: VIEWLET_ID }, () => promise);
+                    }
+                    const source = debugService.getAdapterManager().getDebuggerLabel(session.configuration.type);
+                    progressService.withProgress({
+                        location: 15 ,
+                        title: progressStartEvent.body.title,
+                        cancellable: progressStartEvent.body.cancellable,
+                        source,
+                        delay: 500
+                    }, progressStep => {
+                        let total = 0;
+                        const reportProgress = (progress) => {
+                            let increment = undefined;
+                            if (typeof progress.percentage === 'number') {
+                                increment = progress.percentage - total;
+                                total += increment;
+                            }
+                            progressStep.report({
+                                message: progress.message,
+                                increment,
+                                total: typeof increment === 'number' ? 100 : undefined,
+                            });
+                        };
+                        if (progressStartEvent.body.message) {
+                            reportProgress(progressStartEvent.body);
+                        }
+                        const progressUpdateListener = session.onDidProgressUpdate(e => {
+                            if (e.body.progressId === progressStartEvent.body.progressId) {
+                                reportProgress(e.body);
+                            }
+                        });
+                        return promise.then(() => progressUpdateListener.dispose());
+                    }, () => session.cancel(progressStartEvent.body.progressId));
+                });
+            }
+        };
+        this.toDispose.push(debugService.getViewModel().onDidFocusSession(listenOnProgress));
+        listenOnProgress(debugService.getViewModel().focusedSession);
+        this.toDispose.push(debugService.onWillNewSession(session => {
+            if (!progressListener) {
+                listenOnProgress(session);
+            }
+        }));
+    }
+    dispose() {
+        dispose(this.toDispose);
+    }
+};
+DebugProgressContribution = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IProgressService)),
+    ( __param(2, IViewsService))
+], DebugProgressContribution));
+
+export { DebugProgressContribution };

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

@@ -0,0 +1,169 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { PickerQuickAccessProvider, TriggerAction } from 'vscode/vscode/vs/platform/quickinput/browser/pickerQuickAccess';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { matchesFuzzy } from 'vscode/vscode/vs/base/common/filters';
+import { DEBUG_QUICK_ACCESS_PREFIX, ADD_CONFIGURATION_ID } from './debugCommands.js';
+import { debugConfigure, debugRemoveConfig } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+
+let StartDebugQuickAccessProvider = class StartDebugQuickAccessProvider extends PickerQuickAccessProvider {
+    constructor(debugService, contextService, commandService, notificationService) {
+        super(DEBUG_QUICK_ACCESS_PREFIX, {
+            noResultsPick: {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/debugQuickAccess',
+                    'noDebugResults',
+                    "No matching launch configurations"
+                ))
+            }
+        });
+        this.debugService = debugService;
+        this.contextService = contextService;
+        this.commandService = commandService;
+        this.notificationService = notificationService;
+    }
+    async _getPicks(filter) {
+        const picks = [];
+        if (!this.debugService.getAdapterManager().hasEnabledDebuggers()) {
+            return [];
+        }
+        picks.push({ type: 'separator', label: 'launch.json' });
+        const configManager = this.debugService.getConfigurationManager();
+        let lastGroup;
+        for (const config of configManager.getAllConfigurations()) {
+            const highlights = matchesFuzzy(filter, config.name, true);
+            if (highlights) {
+                if (lastGroup !== config.presentation?.group) {
+                    picks.push({ type: 'separator' });
+                    lastGroup = config.presentation?.group;
+                }
+                picks.push({
+                    label: config.name,
+                    description: this.contextService.getWorkbenchState() === 3  ? config.launch.name : '',
+                    highlights: { label: highlights },
+                    buttons: [{
+                            iconClass: ThemeIcon.asClassName(debugConfigure),
+                            tooltip: ( localizeWithPath(
+                                'vs/workbench/contrib/debug/browser/debugQuickAccess',
+                                'customizeLaunchConfig',
+                                "Configure Launch Configuration"
+                            ))
+                        }],
+                    trigger: () => {
+                        config.launch.openConfigFile({ preserveFocus: false });
+                        return TriggerAction.CLOSE_PICKER;
+                    },
+                    accept: async () => {
+                        await configManager.selectConfiguration(config.launch, config.name);
+                        try {
+                            await this.debugService.startDebugging(config.launch, undefined, { startedByUser: true });
+                        }
+                        catch (error) {
+                            this.notificationService.error(error);
+                        }
+                    }
+                });
+            }
+        }
+        const dynamicProviders = await configManager.getDynamicProviders();
+        if (dynamicProviders.length > 0) {
+            picks.push({
+                type: 'separator', label: ( localizeWithPath('vs/workbench/contrib/debug/browser/debugQuickAccess', {
+                    key: 'contributed',
+                    comment: ['contributed is lower case because it looks better like that in UI. Nothing preceeds it. It is a name of the grouping of debug configurations.']
+                }, "contributed"))
+            });
+        }
+        configManager.getRecentDynamicConfigurations().forEach(({ name, type }) => {
+            const highlights = matchesFuzzy(filter, name, true);
+            if (highlights) {
+                picks.push({
+                    label: name,
+                    highlights: { label: highlights },
+                    buttons: [{
+                            iconClass: ThemeIcon.asClassName(debugRemoveConfig),
+                            tooltip: ( localizeWithPath(
+                                'vs/workbench/contrib/debug/browser/debugQuickAccess',
+                                'removeLaunchConfig',
+                                "Remove Launch Configuration"
+                            ))
+                        }],
+                    trigger: () => {
+                        configManager.removeRecentDynamicConfigurations(name, type);
+                        return TriggerAction.CLOSE_PICKER;
+                    },
+                    accept: async () => {
+                        await configManager.selectConfiguration(undefined, name, undefined, { type });
+                        try {
+                            const { launch, getConfig } = configManager.selectedConfiguration;
+                            const config = await getConfig();
+                            await this.debugService.startDebugging(launch, config, { startedByUser: true });
+                        }
+                        catch (error) {
+                            this.notificationService.error(error);
+                        }
+                    }
+                });
+            }
+        });
+        dynamicProviders.forEach(provider => {
+            picks.push({
+                label: `$(folder) ${provider.label}...`,
+                ariaLabel: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/debugQuickAccess',
+                    { key: 'providerAriaLabel', comment: ['Placeholder stands for the provider label. For example "NodeJS".'] },
+                    "{0} contributed configurations",
+                    provider.label
+                )),
+                accept: async () => {
+                    const pick = await provider.pick();
+                    if (pick) {
+                        await configManager.selectConfiguration(pick.launch, pick.config.name, pick.config, { type: provider.type });
+                        this.debugService.startDebugging(pick.launch, pick.config, { startedByUser: true });
+                    }
+                }
+            });
+        });
+        const visibleLaunches = configManager.getLaunches().filter(launch => !launch.hidden);
+        if (visibleLaunches.length > 0) {
+            picks.push({ type: 'separator', label: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/debugQuickAccess',
+                'configure',
+                "configure"
+            )) });
+        }
+        for (const launch of visibleLaunches) {
+            const label = this.contextService.getWorkbenchState() === 3  ?
+                ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/debugQuickAccess',
+                    "addConfigTo",
+                    "Add Config ({0})...",
+                    launch.name
+                )) :
+                ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/debugQuickAccess',
+                    'addConfiguration',
+                    "Add Configuration..."
+                ));
+            picks.push({
+                label,
+                description: this.contextService.getWorkbenchState() === 3  ? launch.name : '',
+                highlights: { label: matchesFuzzy(filter, label, true) ?? undefined },
+                accept: () => this.commandService.executeCommand(ADD_CONFIGURATION_ID, ( launch.uri.toString()))
+            });
+        }
+        return picks;
+    }
+};
+StartDebugQuickAccessProvider = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, INotificationService))
+], StartDebugQuickAccessProvider));
+
+export { StartDebugQuickAccessProvider };