@codingame/monaco-vscode-debug-service-override 25.1.2 → 26.0.1

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

@@ -32,7 +32,21 @@ import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 
 const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
 let AdapterManager = class AdapterManager extends Disposable {
-    constructor(delegate, editorService, configurationService, quickInputService, instantiationService, commandService, extensionService, contextKeyService, languageService, dialogService, lifecycleService, tasksService, menuService) {
+    constructor(
+        delegate,
+        editorService,
+        configurationService,
+        quickInputService,
+        instantiationService,
+        commandService,
+        extensionService,
+        contextKeyService,
+        languageService,
+        dialogService,
+        lifecycleService,
+        tasksService,
+        menuService
+    ) {
         super();
         this.delegate = delegate;
         this.editorService = editorService;
@@ -71,12 +85,13 @@ let AdapterManager = class AdapterManager extends Disposable {
             this.debugExtensionsAvailable.set(this.debuggers.length > 0);
         }));
         const updateTaskScheduler = this._register(( new RunOnceScheduler(() => this.updateTaskLabels(), 5000)));
-        this._register(Event.any(tasksService.onDidChangeTaskConfig, tasksService.onDidChangeTaskProviders)(() => {
-            updateTaskScheduler.cancel();
-            updateTaskScheduler.schedule();
-        }));
-        this.lifecycleService.when(LifecyclePhase.Eventually)
-            .then(() => this.debugExtensionsAvailable.set(this.debuggers.length > 0));
+        this._register(
+            Event.any(tasksService.onDidChangeTaskConfig, tasksService.onDidChangeTaskProviders)(() => {
+                updateTaskScheduler.cancel();
+                updateTaskScheduler.schedule();
+            })
+        );
+        this.lifecycleService.when(LifecyclePhase.Eventually).then(() => this.debugExtensionsAvailable.set(this.debuggers.length > 0));
         this._register(delegate.onDidNewSession(s => {
             this.usedDebugTypes.add(s.configuration.type);
         }));
@@ -86,15 +101,14 @@ let AdapterManager = class AdapterManager extends Disposable {
         debuggersExtPoint.setHandler((extensions, delta) => {
             delta.added.forEach(added => {
                 added.value.forEach(rawAdapter => {
-                    if (!rawAdapter.type || (typeof rawAdapter.type !== 'string')) {
-                        added.collector.error(( localize(6701, "Debugger 'type' can not be omitted and must be of type 'string'.")));
+                    if (!rawAdapter.type || (typeof rawAdapter.type !== "string")) {
+                        added.collector.error(( localize(7011, "Debugger 'type' can not be omitted and must be of type 'string'.")));
                     }
-                    if (rawAdapter.type !== '*') {
+                    if (rawAdapter.type !== "*") {
                         const existing = this.getDebugger(rawAdapter.type);
                         if (existing) {
                             existing.merge(rawAdapter, added.description);
-                        }
-                        else {
+                        } else {
                             const dbg = this.instantiationService.createInstance(Debugger, this, rawAdapter, added.description);
                             dbg.when?.keys().forEach(key => this.debuggerWhenKeys.add(key));
                             this.debuggers.push(dbg);
@@ -104,7 +118,7 @@ let AdapterManager = class AdapterManager extends Disposable {
             });
             extensions.forEach(extension => {
                 extension.value.forEach(rawAdapter => {
-                    if (rawAdapter.type === '*') {
+                    if (rawAdapter.type === "*") {
                         this.debuggers.forEach(dbg => dbg.merge(rawAdapter, extension.description));
                     }
                 });
@@ -129,51 +143,61 @@ let AdapterManager = class AdapterManager extends Disposable {
         });
     }
     updateDebugAdapterSchema() {
-        const items = launchSchema.properties['configurations'].items;
+        const items = launchSchema.properties["configurations"].items;
         const taskSchema = TaskDefinitionRegistry.getJsonSchema();
         const definitions = {
-            'common': {
+            "common": {
                 properties: {
-                    'name': {
-                        type: 'string',
+                    "name": {
+                        type: "string",
                         description: ( localize(
-                            6702,
+                            7012,
                             "Name of configuration; appears in the launch configuration dropdown menu."
                         )),
-                        default: 'Launch'
+                        default: "Launch"
                     },
-                    'debugServer': {
-                        type: 'number',
+                    "debugServer": {
+                        type: "number",
                         description: ( localize(
-                            6703,
+                            7013,
                             "For debug extension development only: if a port is specified VS Code tries to connect to a debug adapter running in server mode"
                         )),
                         default: 4711
                     },
-                    'preLaunchTask': {
+                    "preLaunchTask": {
                         anyOf: [taskSchema, {
-                                type: ['string']
-                            }],
-                        default: '',
-                        defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localize(6704, "Task to run before debug session starts.")),
-                        examples: this.taskLabels,
+                            type: ["string"]
+                        }],
+                        default: "",
+                        defaultSnippets: [{
+                            body: {
+                                task: "",
+                                type: ""
+                            }
+                        }],
+                        description: ( localize(7014, "Task to run before debug session starts.")),
+                        examples: this.taskLabels
                     },
-                    'postDebugTask': {
+                    "postDebugTask": {
                         anyOf: [taskSchema, {
-                                type: ['string'],
-                            }],
-                        default: '',
-                        defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localize(6705, "Task to run after debug session ends.")),
-                        examples: this.taskLabels,
+                            type: ["string"]
+                        }],
+                        default: "",
+                        defaultSnippets: [{
+                            body: {
+                                task: "",
+                                type: ""
+                            }
+                        }],
+                        description: ( localize(7015, "Task to run after debug session ends.")),
+                        examples: this.taskLabels
                     },
-                    'presentation': presentationSchema,
-                    'internalConsoleOptions': INTERNAL_CONSOLE_OPTIONS_SCHEMA,
-                    'suppressMultipleSessionWarning': {
-                        type: 'boolean',
+                    "presentation": presentationSchema,
+                    "internalConsoleOptions": INTERNAL_CONSOLE_OPTIONS_SCHEMA,
+                    "suppressMultipleSessionWarning": {
+                        type: "boolean",
                         description: ( localize(
-                            6706,
+                            7016,
                             "Disable the warning when trying to start the same debug configuration more than once."
                         )),
                         default: true
@@ -197,7 +221,9 @@ let AdapterManager = class AdapterManager extends Disposable {
         jsonRegistry.registerSchema(launchSchemaId, launchSchema);
     }
     registerDebugAdapterFactory(debugTypes, debugAdapterLauncher) {
-        debugTypes.forEach(debugType => this.debugAdapterFactories.set(debugType, debugAdapterLauncher));
+        debugTypes.forEach(
+            debugType => this.debugAdapterFactories.set(debugType, debugAdapterLauncher)
+        );
         this.debuggersAvailable.set(this.hasEnabledDebuggers());
         this._onDidRegisterDebugger.fire();
         return {
@@ -273,10 +299,10 @@ let AdapterManager = class AdapterManager extends Disposable {
     }
     canSetBreakpointsIn(model) {
         const languageId = model.getLanguageId();
-        if (!languageId || languageId === 'jsonc' || languageId === 'log') {
+        if (!languageId || languageId === "jsonc" || languageId === "log") {
             return false;
         }
-        if (this.configurationService.getValue('debug').allowBreakpointsEverywhere) {
+        if (this.configurationService.getValue("debug").allowBreakpointsEverywhere) {
             return true;
         }
         return ( this.breakpointContributions.some(breakpoints => breakpoints.language === languageId && breakpoints.enabled));
@@ -289,9 +315,7 @@ let AdapterManager = class AdapterManager extends Disposable {
         return adapter && adapter.enabled ? adapter : undefined;
     }
     someDebuggerInterestedInLanguage(languageId) {
-        return !!this.debuggers
-            .filter(d => d.enabled)
-            .find(a => a.interestedInLanguage(languageId));
+        return !!this.debuggers.filter(d => d.enabled).find(a => a.interestedInLanguage(languageId));
     }
     async guessDebugger(gettingConfigurations) {
         const activeTextEditorControl = this.editorService.activeTextEditorControl;
@@ -304,37 +328,39 @@ let AdapterManager = class AdapterManager extends Disposable {
             if (language) {
                 languageLabel = this.languageService.getLanguageName(language);
             }
-            const adapters = this.debuggers
-                .filter(a => a.enabled)
-                .filter(a => language && a.interestedInLanguage(language));
+            const adapters = this.debuggers.filter(a => a.enabled).filter(a => language && a.interestedInLanguage(language));
             if (adapters.length === 1) {
-                return { debugger: adapters[0] };
+                return {
+                    debugger: adapters[0]
+                };
             }
             if (adapters.length > 1) {
                 candidates = adapters;
             }
         }
         if ((!languageLabel || gettingConfigurations || (model && this.canSetBreakpointsIn(model))) && candidates.length === 0) {
-            await this.activateDebuggers('onDebugInitialConfigurations');
-            candidates = this.debuggers
-                .filter(a => a.enabled)
-                .filter(dbg => dbg.hasInitialConfiguration() || dbg.hasDynamicConfigurationProviders() || dbg.hasConfigurationProvider());
+            await this.activateDebuggers("onDebugInitialConfigurations");
+            candidates = this.debuggers.filter(a => a.enabled).filter(
+                dbg => dbg.hasInitialConfiguration() || dbg.hasDynamicConfigurationProviders() || dbg.hasConfigurationProvider()
+            );
         }
         if (candidates.length === 0 && languageLabel) {
-            if (languageLabel.indexOf(' ') >= 0) {
+            if (languageLabel.indexOf(" ") >= 0) {
                 languageLabel = `'${languageLabel}'`;
             }
-            const { confirmed } = await this.dialogService.confirm({
+            const {
+                confirmed
+            } = await this.dialogService.confirm({
                 type: Severity.Warning,
                 message: ( localize(
-                    6707,
+                    7017,
                     "You don't have an extension for debugging {0}. Should we find a {0} extension in the Marketplace?",
                     languageLabel
                 )),
-                primaryButton: ( localize(6708, "&&Find {0} extension", languageLabel))
+                primaryButton: ( localize(7018, "&&Find {0} extension", languageLabel))
             });
             if (confirmed) {
-                await this.commandService.executeCommand('debug.installAdditionalDebuggers', languageLabel);
+                await this.commandService.executeCommand("debug.installAdditionalDebuggers", languageLabel);
             }
             return undefined;
         }
@@ -347,52 +373,80 @@ let AdapterManager = class AdapterManager extends Disposable {
             const descriptor = d.getMainExtensionDescriptor();
             if (descriptor.id && !!this.earlyActivatedExtensions?.has(descriptor.id)) {
                 suggestedCandidates.push(d);
-            }
-            else if (( this.usedDebugTypes.has(d.type))) {
+            } else if (( this.usedDebugTypes.has(d.type))) {
                 suggestedCandidates.push(d);
-            }
-            else {
+            } else {
                 otherCandidates.push(d);
             }
         });
         const picks = [];
         const dynamic = await this.delegate.configurationManager().getDynamicProviders();
         if (suggestedCandidates.length > 0) {
-            picks.push({ type: 'separator', label: ( localize(6709, "Suggested")) }, ...( suggestedCandidates.map(c => ({ label: c.label, pick: () => ({ debugger: c }) }))));
+            picks.push({
+                type: "separator",
+                label: ( localize(7019, "Suggested"))
+            }, ...( suggestedCandidates.map(c => ({
+                label: c.label,
+                pick: () => ({
+                    debugger: c
+                })
+            }))));
         }
         if (otherCandidates.length > 0) {
             if (picks.length > 0) {
-                picks.push({ type: 'separator', label: '' });
+                picks.push({
+                    type: "separator",
+                    label: ""
+                });
             }
-            picks.push(...( otherCandidates.map(c => ({ label: c.label, pick: () => ({ debugger: c }) }))));
+            picks.push(...( otherCandidates.map(c => ({
+                label: c.label,
+                pick: () => ({
+                    debugger: c
+                })
+            }))));
         }
         if (dynamic.length) {
             if (picks.length) {
-                picks.push({ type: 'separator', label: '' });
+                picks.push({
+                    type: "separator",
+                    label: ""
+                });
             }
             for (const d of dynamic) {
                 picks.push({
-                    label: ( localize(6710, "More {0} options...", d.label)),
+                    label: ( localize(7020, "More {0} options...", d.label)),
                     pick: async () => {
                         const cfg = await d.pick();
                         if (!cfg) {
                             return undefined;
                         }
-                        return cfg && { debugger: this.getDebugger(d.type), withConfig: cfg };
-                    },
+                        return cfg && {
+                            debugger: this.getDebugger(d.type),
+                            withConfig: cfg
+                        };
+                    }
                 });
             }
         }
-        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( localize(6711, "Install an extension for {0}...", languageLabel)) : ( localize(6712, "Install extension...")) });
+        picks.push({
+            type: "separator",
+            label: ""
+        }, {
+            label: languageLabel ? ( localize(7021, "Install an extension for {0}...", languageLabel)) : ( localize(7022, "Install extension..."))
+        });
         const contributed = this.menuService.getMenuActions(MenuId.DebugCreateConfiguration, this.contextKeyService);
         for (const [, action] of contributed) {
             for (const item of action) {
                 picks.push(item);
             }
         }
-        const placeHolder = ( localize(6713, "Select debugger"));
-        return this.quickInputService.pick(picks, { activeItem: picks[0], placeHolder }).then(async (picked) => {
-            if (picked && 'pick' in picked && typeof picked.pick === 'function') {
+        const placeHolder = ( localize(7023, "Select debugger"));
+        return this.quickInputService.pick(picks, {
+            activeItem: picks[0],
+            placeHolder
+        }).then(async picked => {
+            if (picked && "pick" in picked && typeof picked.pick === "function") {
                 return await picked.pick();
             }
             if (picked instanceof MenuItemAction) {
@@ -400,7 +454,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                 return;
             }
             if (picked) {
-                this.commandService.executeCommand('debug.installAdditionalDebuggers', languageLabel);
+                this.commandService.executeCommand("debug.installAdditionalDebuggers", languageLabel);
             }
             return undefined;
         });
@@ -420,7 +474,7 @@ let AdapterManager = class AdapterManager extends Disposable {
         this.initExtensionActivationsIfNeeded();
         const promises = [
             this.extensionService.activateByEvent(activationEvent),
-            this.extensionService.activateByEvent('onDebug')
+            this.extensionService.activateByEvent("onDebug")
         ];
         if (debugType) {
             promises.push(this.extensionService.activateByEvent(`${activationEvent}:${debugType}`));
@@ -428,19 +482,6 @@ let AdapterManager = class AdapterManager extends Disposable {
         await Promise.all(promises);
     }
 };
-AdapterManager = ( __decorate([
-    ( __param(1, IEditorService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, ICommandService)),
-    ( __param(6, IExtensionService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, ILanguageService)),
-    ( __param(9, IDialogService)),
-    ( __param(10, ILifecycleService)),
-    ( __param(11, ITaskService)),
-    ( __param(12, IMenuService))
-], AdapterManager));
+AdapterManager = ( __decorate([( __param(1, IEditorService)), ( __param(2, IConfigurationService)), ( __param(3, IQuickInputService)), ( __param(4, IInstantiationService)), ( __param(5, ICommandService)), ( __param(6, IExtensionService)), ( __param(7, IContextKeyService)), ( __param(8, ILanguageService)), ( __param(9, IDialogService)), ( __param(10, ILifecycleService)), ( __param(11, ITaskService)), ( __param(12, IMenuService))], AdapterManager));
 
 export { AdapterManager };