@codingame/monaco-vscode-debug-service-override 4.5.0 → 4.5.2

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

@@ -30,6 +30,7 @@ import { setupCustomHover } from 'vscode/vscode/vs/base/browser/ui/hover/updatab
 import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
 
 var StartDebugActionViewItem_1;
+const _moduleId = "vs/workbench/contrib/debug/browser/debugActionViewItems";
 const $ = $$1;
 let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseActionViewItem {
     static { StartDebugActionViewItem_1 = this; }
@@ -46,17 +47,13 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         this.selected = 0;
         this.providers = [];
         this.toDispose = [];
-        this.selectBox = ( new SelectBox(
+        this.selectBox = ( (new SelectBox(
             [],
             -1,
             contextViewService,
             defaultSelectBoxStyles,
-            { ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugActionViewItems',
-                'debugLaunchConfigurations',
-                'Debug Launch Configurations'
-            )) }
-        ));
+            { ariaLabel: ( localizeWithPath(_moduleId, 0, 'Debug Launch Configurations')) }
+        )));
         this.selectBox.setFocusable(false);
         this.toDispose.push(this.selectBox);
         this.registerListeners();
@@ -99,7 +96,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
             this.start.classList.remove('active');
         }));
         this.toDispose.push(addDisposableListener(this.start, EventType.KEY_DOWN, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(17 )) {
                 this.start.tabIndex = -1;
                 this.selectBox.focus();
@@ -119,7 +116,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         const selectBoxContainer = $('.configuration');
         this.selectBox.render(append(container, selectBoxContainer));
         this.toDispose.push(addDisposableListener(selectBoxContainer, EventType.KEY_DOWN, (e) => {
-            const event = ( new StandardKeyboardEvent(e));
+            const event = ( (new StandardKeyboardEvent(e)));
             if (event.equals(15 )) {
                 this.selectBox.setFocusable(false);
                 this.start.tabIndex = 0;
@@ -213,11 +210,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
             });
         });
         if (this.debugOptions.length === 0) {
-            this.debugOptions.push({ label: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugActionViewItems',
-                'noConfigurations',
-                "No Configurations"
-            )), handler: async () => false });
+            this.debugOptions.push({ label: ( localizeWithPath(_moduleId, 1, "No Configurations")), handler: async () => false });
         }
         this.debugOptions.push({ label: StartDebugActionViewItem_1.SEPARATOR, handler: () => Promise.resolve(false) });
         disabledIdxs.push(this.debugOptions.length - 1);
@@ -235,43 +228,30 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
             });
         });
         manager.getLaunches().filter(l => !l.hidden).forEach(l => {
-            const label = inWorkspace ? ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugActionViewItems',
-                "addConfigTo",
-                "Add Config ({0})...",
-                l.name
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugActionViewItems',
-                'addConfiguration',
-                "Add Configuration..."
-            ));
+            const label = inWorkspace ? ( localizeWithPath(_moduleId, 2, "Add Config ({0})...", l.name)) : ( localizeWithPath(_moduleId, 3, "Add Configuration..."));
             this.debugOptions.push({
                 label, handler: async () => {
-                    await this.commandService.executeCommand(ADD_CONFIGURATION_ID, ( l.uri.toString()));
+                    await this.commandService.executeCommand(ADD_CONFIGURATION_ID, ( (l.uri.toString())));
                     return false;
                 }
             });
         });
-        this.selectBox.setOptions(( this.debugOptions.map(
+        this.selectBox.setOptions(( (this.debugOptions.map(
             (data, index) => ({ text: data.label, isDisabled: disabledIdxs.indexOf(index) !== -1 })
-        )), this.selected);
+        ))), this.selected);
     }
 };
-StartDebugActionViewItem = StartDebugActionViewItem_1 = ( __decorate([
-    ( __param(3, IDebugService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, ICommandService)),
-    ( __param(6, IWorkspaceContextService)),
-    ( __param(7, IContextViewService)),
-    ( __param(8, IKeybindingService))
-], StartDebugActionViewItem));
+StartDebugActionViewItem = StartDebugActionViewItem_1 = ( (__decorate([
+    ( (__param(3, IDebugService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, ICommandService))),
+    ( (__param(6, IWorkspaceContextService))),
+    ( (__param(7, IContextViewService))),
+    ( (__param(8, IKeybindingService)))
+], StartDebugActionViewItem)));
 let FocusSessionActionViewItem = class FocusSessionActionViewItem extends SelectActionViewItem {
     constructor(action, session, debugService, contextViewService, configurationService) {
-        super(null, action, [], -1, contextViewService, defaultSelectBoxStyles, { ariaLabel: ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugActionViewItems',
-            'debugSession',
-            'Debug Session'
-        )) });
+        super(null, action, [], -1, contextViewService, defaultSelectBoxStyles, { ariaLabel: ( localizeWithPath(_moduleId, 4, 'Debug Session')) });
         this.debugService = debugService;
         this.configurationService = configurationService;
         this._register(this.debugService.getViewModel().onDidFocusSession(() => {
@@ -302,14 +282,14 @@ let FocusSessionActionViewItem = class FocusSessionActionViewItem extends Select
             session = this.getSelectedSession();
         }
         const sessions = this.getSessions();
-        const names = ( sessions.map(s => {
+        const names = ( (sessions.map(s => {
             const label = s.getLabel();
             if (s.parentSession) {
                 return `\u00A0\u00A0${label}`;
             }
             return label;
-        }));
-        this.setOptions(( names.map(data => ({ text: data }))), session ? sessions.indexOf(session) : undefined);
+        })));
+        this.setOptions(( (names.map(data => ({ text: data })))), session ? sessions.indexOf(session) : undefined);
     }
     getSelectedSession() {
         const session = this.debugService.getViewModel().focusedSession;
@@ -328,10 +308,10 @@ let FocusSessionActionViewItem = class FocusSessionActionViewItem extends Select
         return focusedSession;
     }
 };
-FocusSessionActionViewItem = ( __decorate([
-    ( __param(2, IDebugService)),
-    ( __param(3, IContextViewService)),
-    ( __param(4, IConfigurationService))
-], FocusSessionActionViewItem));
+FocusSessionActionViewItem = ( (__decorate([
+    ( (__param(2, IDebugService))),
+    ( (__param(3, IContextViewService))),
+    ( (__param(4, IConfigurationService)))
+], FocusSessionActionViewItem)));
 
 export { FocusSessionActionViewItem, StartDebugActionViewItem };

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

@@ -24,7 +24,8 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 
-const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
+const _moduleId = "vs/workbench/contrib/debug/browser/debugAdapterManager";
+const jsonRegistry = ( (Registry.as(Extensions.JSONContribution)));
 let AdapterManager = class AdapterManager extends Disposable {
     constructor(delegate, editorService, configurationService, quickInputService, instantiationService, commandService, extensionService, contextKeyService, languageService, dialogService, lifecycleService) {
         super();
@@ -38,12 +39,12 @@ let AdapterManager = class AdapterManager extends Disposable {
         this.languageService = languageService;
         this.dialogService = dialogService;
         this.lifecycleService = lifecycleService;
-        this.debugAdapterFactories = ( new Map());
-        this._onDidRegisterDebugger = ( new Emitter());
-        this._onDidDebuggersExtPointRead = ( new Emitter());
+        this.debugAdapterFactories = ( (new Map()));
+        this._onDidRegisterDebugger = ( (new Emitter()));
+        this._onDidDebuggersExtPointRead = ( (new Emitter()));
         this.breakpointContributions = [];
-        this.debuggerWhenKeys = ( new Set());
-        this.usedDebugTypes = ( new Set());
+        this.debuggerWhenKeys = ( (new Set()));
+        this.usedDebugTypes = ( (new Set()));
         this.adapterDescriptorFactories = [];
         this.debuggers = [];
         this.registerListeners();
@@ -72,8 +73,8 @@ let AdapterManager = class AdapterManager extends Disposable {
                 added.value.forEach(rawAdapter => {
                     if (!rawAdapter.type || (typeof rawAdapter.type !== 'string')) {
                         added.collector.error(( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugNoType',
+                            _moduleId,
+                            0,
                             "Debugger 'type' can not be omitted and must be of type 'string'."
                         )));
                     }
@@ -98,16 +99,16 @@ let AdapterManager = class AdapterManager extends Disposable {
                 });
             });
             delta.removed.forEach(removed => {
-                const removedTypes = ( removed.value.map(rawAdapter => rawAdapter.type));
+                const removedTypes = ( (removed.value.map(rawAdapter => rawAdapter.type)));
                 this.debuggers = this.debuggers.filter(d => removedTypes.indexOf(d.type) === -1);
             });
             this.updateDebugAdapterSchema();
             this._onDidDebuggersExtPointRead.fire();
         });
         breakpointsExtPoint.setHandler(extensions => {
-            this.breakpointContributions = extensions.flatMap(ext => ( ext.value.map(
+            this.breakpointContributions = extensions.flatMap(ext => ( (ext.value.map(
                 breakpoint => this.instantiationService.createInstance(Breakpoints, breakpoint)
-            )));
+            ))));
         });
     }
     updateDebugAdapterSchema() {
@@ -119,8 +120,8 @@ let AdapterManager = class AdapterManager extends Disposable {
                     'name': {
                         type: 'string',
                         description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugName',
+                            _moduleId,
+                            1,
                             "Name of configuration; appears in the launch configuration dropdown menu."
                         )),
                         default: 'Launch'
@@ -128,8 +129,8 @@ let AdapterManager = class AdapterManager extends Disposable {
                     'debugServer': {
                         type: 'number',
                         description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugServer',
+                            _moduleId,
+                            2,
                             "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
@@ -140,11 +141,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                             }],
                         default: '',
                         defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugPrelaunchTask',
-                            "Task to run before debug session starts."
-                        ))
+                        description: ( localizeWithPath(_moduleId, 3, "Task to run before debug session starts."))
                     },
                     'postDebugTask': {
                         anyOf: [taskSchema, {
@@ -152,19 +149,15 @@ let AdapterManager = class AdapterManager extends Disposable {
                             }],
                         default: '',
                         defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'debugPostDebugTask',
-                            "Task to run after debug session ends."
-                        ))
+                        description: ( localizeWithPath(_moduleId, 4, "Task to run after debug session ends."))
                     },
                     'presentation': presentationSchema,
                     'internalConsoleOptions': INTERNAL_CONSOLE_OPTIONS_SCHEMA,
                     'suppressMultipleSessionWarning': {
                         type: 'boolean',
                         description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                            'suppressMultipleSessionWarning',
+                            _moduleId,
+                            5,
                             "Disable the warning when trying to start the same debug configuration more than once."
                         )),
                         default: true
@@ -270,7 +263,9 @@ let AdapterManager = class AdapterManager extends Disposable {
         if (this.configurationService.getValue('debug').allowBreakpointsEverywhere) {
             return true;
         }
-        return ( this.breakpointContributions.some(breakpoints => breakpoints.language === languageId && breakpoints.enabled));
+        return (
+             (this.breakpointContributions.some(breakpoints => breakpoints.language === languageId && breakpoints.enabled))
+        );
     }
     getDebugger(type) {
         return this.debuggers.find(dbg => equalsIgnoreCase(dbg.type, type));
@@ -318,17 +313,12 @@ let AdapterManager = class AdapterManager extends Disposable {
             const { confirmed } = await this.dialogService.confirm({
                 type: Severity$1.Warning,
                 message: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                    'CouldNotFindLanguage',
+                    _moduleId,
+                    6,
                     "You don't have an extension for debugging {0}. Should we find a {0} extension in the Marketplace?",
                     languageLabel
                 )),
-                primaryButton: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                    { key: 'findExtension', comment: ['&& denotes a mnemonic'] },
-                    "&&Find {0} extension",
-                    languageLabel
-                ))
+                primaryButton: ( localizeWithPath(_moduleId, 7, "&&Find {0} extension", languageLabel))
             });
             if (confirmed) {
                 await this.commandService.executeCommand('debug.installAdditionalDebuggers', languageLabel);
@@ -345,7 +335,7 @@ let AdapterManager = class AdapterManager extends Disposable {
             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 {
@@ -354,33 +344,16 @@ let AdapterManager = class AdapterManager extends Disposable {
         });
         const picks = [];
         if (suggestedCandidates.length > 0) {
-            picks.push({ type: 'separator', label: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/debugAdapterManager',
-                'suggestedDebuggers',
-                "Suggested"
-            )) }, ...( suggestedCandidates.map(c => ({ label: c.label, debugger: c }))));
+            picks.push({ type: 'separator', label: ( localizeWithPath(_moduleId, 8, "Suggested")) }, ...( (suggestedCandidates.map(c => ({ label: c.label, debugger: c })))));
         }
         if (otherCandidates.length > 0) {
             if (picks.length > 0) {
                 picks.push({ type: 'separator', label: '' });
             }
-            picks.push(...( otherCandidates.map(c => ({ label: c.label, debugger: c }))));
+            picks.push(...( (otherCandidates.map(c => ({ label: c.label, debugger: c })))));
         }
-        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-            'installLanguage',
-            "Install an extension for {0}...",
-            languageLabel
-        )) : ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-            'installExt',
-            "Install extension..."
-        )) });
-        const placeHolder = ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugAdapterManager',
-            'selectDebug',
-            "Select debugger"
-        ));
+        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( localizeWithPath(_moduleId, 9, "Install an extension for {0}...", languageLabel)) : ( localizeWithPath(_moduleId, 10, "Install extension...")) });
+        const placeHolder = ( localizeWithPath(_moduleId, 11, "Select debugger"));
         return this.quickInputService.pick(picks, { activeItem: picks[0], placeHolder })
             .then(picked => {
             if (picked && picked.debugger) {
@@ -394,7 +367,7 @@ let AdapterManager = class AdapterManager extends Disposable {
     }
     initExtensionActivationsIfNeeded() {
         if (!this.earlyActivatedExtensions) {
-            this.earlyActivatedExtensions = ( new Set());
+            this.earlyActivatedExtensions = ( (new Set()));
             const status = this.extensionService.getExtensionsStatus();
             for (const id in status) {
                 if (!!status[id].activationTimes) {
@@ -415,17 +388,17 @@ 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))
-], 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)))
+], AdapterManager)));
 
 export { AdapterManager };