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

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

@@ -32,7 +32,8 @@ import { IHistoryService } from 'vscode/vscode/vs/workbench/services/history/com
 import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences.service';
 import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles.service';
 
-const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
+const _moduleId = "vs/workbench/contrib/debug/browser/debugConfigurationManager";
+const jsonRegistry = ( (Registry.as(Extensions.JSONContribution)));
 jsonRegistry.registerSchema(launchSchemaId, launchSchema);
 const DEBUG_SELECTED_CONFIG_NAME_KEY = 'debug.selectedconfigname';
 const DEBUG_SELECTED_ROOT = 'debug.selectedroot';
@@ -51,8 +52,8 @@ let ConfigurationManager = class ConfigurationManager {
         this.uriIdentityService = uriIdentityService;
         this.getSelectedConfig = () => Promise.resolve(undefined);
         this.selectedDynamic = false;
-        this._onDidSelectConfigurationName = ( new Emitter());
-        this._onDidChangeConfigurationProviders = ( new Emitter());
+        this._onDidSelectConfigurationName = ( (new Emitter()));
+        this._onDidChangeConfigurationProviders = ( (new Emitter()));
         this.onDidChangeConfigurationProviders = this._onDidChangeConfigurationProviders.event;
         this.configProviders = [];
         this.toDispose = [this._onDidChangeConfigurationProviders];
@@ -61,7 +62,7 @@ let ConfigurationManager = class ConfigurationManager {
         this.registerListeners();
         const previousSelectedRoot = this.storageService.get(DEBUG_SELECTED_ROOT, 1 );
         const previousSelectedType = this.storageService.get(DEBUG_SELECTED_TYPE, 1 );
-        const previousSelectedLaunch = this.launches.find(l => ( l.uri.toString()) === previousSelectedRoot);
+        const previousSelectedLaunch = this.launches.find(l => ( (l.uri.toString())) === previousSelectedRoot);
         const previousSelectedName = this.storageService.get(DEBUG_SELECTED_CONFIG_NAME_KEY, 1 );
         this.debugConfigurationTypeContext = CONTEXT_DEBUG_CONFIGURATION_TYPE.bindTo(contextKeyService);
         const dynamicConfig = previousSelectedType ? { type: previousSelectedType } : undefined;
@@ -109,7 +110,7 @@ let ConfigurationManager = class ConfigurationManager {
         };
         let resolvedType = config.type ?? type;
         let result = config;
-        for (let seen = ( new Set()); result && !( seen.has(resolvedType));) {
+        for (let seen = ( (new Set())); result && !( (seen.has(resolvedType)));) {
             seen.add(resolvedType);
             result = await resolveDebugConfigurationForType(resolvedType, result);
             result = await resolveDebugConfigurationForType('*', result);
@@ -121,16 +122,16 @@ let ConfigurationManager = class ConfigurationManager {
         const providers = this.configProviders.filter(p => p.type === type && p.resolveDebugConfigurationWithSubstitutedVariables)
             .concat(this.configProviders.filter(p => p.type === '*' && p.resolveDebugConfigurationWithSubstitutedVariables));
         let result = config;
-        await sequence(( providers.map(provider => async () => {
+        await sequence(( (providers.map(provider => async () => {
             if (result) {
                 result = await provider.resolveDebugConfigurationWithSubstitutedVariables(folderUri, result, token);
             }
-        })));
+        }))));
         return result;
     }
     async provideDebugConfigurations(folderUri, type, token) {
         await this.adapterManager.activateDebuggers('onDebugInitialConfigurations');
-        const results = await Promise.all(( this.configProviders.filter(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Initial && p.provideDebugConfigurations).map(p => p.provideDebugConfigurations(folderUri, token))));
+        const results = await Promise.all(( (this.configProviders.filter(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Initial && p.provideDebugConfigurations).map(p => p.provideDebugConfigurations(folderUri, token)))));
         return results.reduce((first, second) => first.concat(second), []);
     }
     async getDynamicProviders() {
@@ -160,78 +161,72 @@ let ConfigurationManager = class ConfigurationManager {
                 }
             }
             return acc;
-        }, ( new Set()));
+        }, ( (new Set())));
         for (const configProvider of this.configProviders) {
             if (configProvider.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic) {
                 debugDynamicExtensionsTypes.add(configProvider.type);
             }
         }
-        return ( [...debugDynamicExtensionsTypes].map(type => {
-            return {
-                label: this.adapterManager.getDebuggerLabel(type),
-                getProvider: async () => {
-                    await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
-                    return this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
-                },
-                type,
-                pick: async () => {
-                    await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
-                    const token = ( new CancellationTokenSource());
-                    const picks = [];
-                    const provider = this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
-                    this.getLaunches().forEach(launch => {
-                        if (launch.workspace && provider) {
-                            picks.push(provider.provideDebugConfigurations(launch.workspace.uri, token.token).then(configurations => ( configurations.map(config => ({
-                                label: config.name,
-                                description: launch.name,
-                                config,
-                                buttons: [{
-                                        iconClass: ThemeIcon.asClassName(debugConfigure),
-                                        tooltip: ( localizeWithPath(
-                                            'vs/workbench/contrib/debug/browser/debugConfigurationManager',
-                                            'editLaunchConfig',
-                                            "Edit Debug Configuration in launch.json"
-                                        ))
-                                    }],
-                                launch
-                            })))));
+        return (
+             ([...debugDynamicExtensionsTypes].map(type => {
+                return {
+                    label: this.adapterManager.getDebuggerLabel(type),
+                    getProvider: async () => {
+                        await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
+                        return this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
+                    },
+                    type,
+                    pick: async () => {
+                        await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
+                        const token = ( (new CancellationTokenSource()));
+                        const picks = [];
+                        const provider = this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
+                        this.getLaunches().forEach(launch => {
+                            if (launch.workspace && provider) {
+                                picks.push(provider.provideDebugConfigurations(launch.workspace.uri, token.token).then(configurations => ( (configurations.map(config => ({
+                                    label: config.name,
+                                    description: launch.name,
+                                    config,
+                                    buttons: [{
+                                            iconClass: ThemeIcon.asClassName(debugConfigure),
+                                            tooltip: ( localizeWithPath(_moduleId, 0, "Edit Debug Configuration in launch.json"))
+                                        }],
+                                    launch
+                                }))))));
+                            }
+                        });
+                        const disposables = ( (new DisposableStore()));
+                        const input = disposables.add(this.quickInputService.createQuickPick());
+                        input.busy = true;
+                        input.placeholder = ( localizeWithPath(_moduleId, 1, "Select Launch Configuration"));
+                        const chosenPromise = ( (new Promise(resolve => {
+                            disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
+                            disposables.add(input.onDidTriggerItemButton(async (context) => {
+                                resolve(undefined);
+                                const { launch, config } = context.item;
+                                await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
+                                await launch.writeConfiguration(config);
+                                await this.selectConfiguration(launch, config.name);
+                                this.removeRecentDynamicConfigurations(config.name, config.type);
+                            }));
+                            disposables.add(input.onDidHide(() => resolve(undefined)));
+                        })));
+                        const nestedPicks = await Promise.all(picks);
+                        const items = flatten(nestedPicks);
+                        input.items = items;
+                        input.busy = false;
+                        input.show();
+                        const chosen = await chosenPromise;
+                        disposables.dispose();
+                        if (!chosen) {
+                            token.cancel();
+                            return;
                         }
-                    });
-                    const disposables = ( new DisposableStore());
-                    const input = disposables.add(this.quickInputService.createQuickPick());
-                    input.busy = true;
-                    input.placeholder = ( localizeWithPath(
-                        'vs/workbench/contrib/debug/browser/debugConfigurationManager',
-                        'selectConfiguration',
-                        "Select Launch Configuration"
-                    ));
-                    const chosenPromise = ( new Promise(resolve => {
-                        disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
-                        disposables.add(input.onDidTriggerItemButton(async (context) => {
-                            resolve(undefined);
-                            const { launch, config } = context.item;
-                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
-                            await launch.writeConfiguration(config);
-                            await this.selectConfiguration(launch, config.name);
-                            this.removeRecentDynamicConfigurations(config.name, config.type);
-                        }));
-                        disposables.add(input.onDidHide(() => resolve(undefined)));
-                    }));
-                    const nestedPicks = await Promise.all(picks);
-                    const items = flatten(nestedPicks);
-                    input.items = items;
-                    input.busy = false;
-                    input.show();
-                    const chosen = await chosenPromise;
-                    disposables.dispose();
-                    if (!chosen) {
-                        token.cancel();
-                        return;
+                        return chosen;
                     }
-                    return chosen;
-                }
-            };
-        }));
+                };
+            }))
+        );
     }
     getAllConfigurations() {
         const all = [];
@@ -275,9 +270,9 @@ let ConfigurationManager = class ConfigurationManager {
         }));
     }
     initLaunches() {
-        this.launches = ( this.contextService.getWorkspace().folders.map(
+        this.launches = ( (this.contextService.getWorkspace().folders.map(
             folder => this.instantiationService.createInstance(Launch, this, this.adapterManager, folder)
-        ));
+        )));
         if (this.contextService.getWorkbenchState() === 3 ) {
             this.launches.push(this.instantiationService.createInstance(WorkspaceLaunch, this, this.adapterManager));
         }
@@ -288,10 +283,10 @@ let ConfigurationManager = class ConfigurationManager {
     }
     setCompoundSchemaValues() {
         const compoundConfigurationsSchema = launchSchema.properties['compounds'].items.properties['configurations'];
-        const launchNames = ( this.launches.map(l => l.getConfigurationNames(true))).reduce((first, second) => first.concat(second), []);
+        const launchNames = ( (this.launches.map(l => l.getConfigurationNames(true)))).reduce((first, second) => first.concat(second), []);
         compoundConfigurationsSchema.items.oneOf[0].enum = launchNames;
         compoundConfigurationsSchema.items.oneOf[1].properties.name.enum = launchNames;
-        const folderNames = ( this.contextService.getWorkspace().folders.map(f => f.name));
+        const folderNames = ( (this.contextService.getWorkspace().folders.map(f => f.name)));
         compoundConfigurationsSchema.items.oneOf[1].properties.folder.enum = folderNames;
         jsonRegistry.registerSchema(launchSchemaId, launchSchema);
     }
@@ -334,7 +329,7 @@ let ConfigurationManager = class ConfigurationManager {
         const previousSelectedDynamic = this.selectedDynamic;
         this.selectedLaunch = launch;
         if (this.selectedLaunch) {
-            this.storageService.store(DEBUG_SELECTED_ROOT, ( this.selectedLaunch.uri.toString()), 1 , 1 );
+            this.storageService.store(DEBUG_SELECTED_ROOT, ( (this.selectedLaunch.uri.toString())), 1 , 1 );
         }
         else {
             this.storageService.remove(DEBUG_SELECTED_ROOT, 1 );
@@ -353,10 +348,10 @@ let ConfigurationManager = class ConfigurationManager {
             if (!config) {
                 const providers = (await this.getDynamicProviders()).filter(p => p.type === type);
                 this.getSelectedConfig = async () => {
-                    const activatedProviders = await Promise.all(( providers.map(p => p.getProvider())));
+                    const activatedProviders = await Promise.all(( (providers.map(p => p.getProvider()))));
                     const provider = activatedProviders.length > 0 ? activatedProviders[0] : undefined;
                     if (provider && launch && launch.workspace) {
-                        const token = ( new CancellationTokenSource());
+                        const token = ( (new CancellationTokenSource()));
                         const dynamicConfigs = await provider.provideDebugConfigurations(launch.workspace.uri, token.token);
                         const dynamicConfig = dynamicConfigs.find(c => c.name === name);
                         if (dynamicConfig) {
@@ -408,17 +403,17 @@ let ConfigurationManager = class ConfigurationManager {
         this.toDispose = dispose(this.toDispose);
     }
 };
-ConfigurationManager = ( __decorate([
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IExtensionService)),
-    ( __param(7, IHistoryService)),
-    ( __param(8, IUriIdentityService)),
-    ( __param(9, IContextKeyService))
-], ConfigurationManager));
+ConfigurationManager = ( (__decorate([
+    ( (__param(1, IWorkspaceContextService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IQuickInputService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IStorageService))),
+    ( (__param(6, IExtensionService))),
+    ( (__param(7, IHistoryService))),
+    ( (__param(8, IUriIdentityService))),
+    ( (__param(9, IContextKeyService)))
+], ConfigurationManager)));
 class AbstractLaunch {
     constructor(configurationManager, adapterManager) {
         this.configurationManager = configurationManager;
@@ -442,12 +437,16 @@ class AbstractLaunch {
                 configurations.push(...config.configurations.filter(cfg => cfg && typeof cfg.name === 'string'));
             }
             if (ignoreCompoundsAndPresentation) {
-                return ( configurations.map(c => c.name));
+                return (
+                     (configurations.map(c => c.name))
+                );
             }
             if (config.compounds) {
                 configurations.push(...config.compounds.filter(compound => typeof compound.name === 'string' && compound.configurations && compound.configurations.length));
             }
-            return ( getVisibleAndSorted(configurations).map(c => c.name));
+            return (
+                 (getVisibleAndSorted(configurations).map(c => c.name))
+            );
         }
     }
     getConfiguration(name) {
@@ -508,7 +507,7 @@ let Launch = class Launch extends AbstractLaunch {
         let content = '';
         try {
             const fileContent = await this.fileService.readFile(resource);
-            content = ( fileContent.value.toString());
+            content = ( (fileContent.value.toString()));
         }
         catch {
             content = await this.getInitialConfigurationContent(this.workspace.uri, type, !suppressInitialConfigs, token);
@@ -520,7 +519,12 @@ let Launch = class Launch extends AbstractLaunch {
                 await this.textFileService.write(resource, content);
             }
             catch (error) {
-                throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugConfigurationManager', 'DebugConfig.failed', "Unable to create 'launch.json' file inside the '.vscode' folder ({0}).", error.message));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    2,
+                    "Unable to create 'launch.json' file inside the '.vscode' folder ({0}).",
+                    error.message
+                ))));
             }
         }
         const index = content.indexOf(`"${this.configurationManager.selectedConfiguration.name}"`);
@@ -554,12 +558,12 @@ let Launch = class Launch extends AbstractLaunch {
         await this.configurationService.updateValue('launch', fullConfig, { resource: this.workspace.uri }, 6 );
     }
 };
-Launch = ( __decorate([
-    ( __param(3, IFileService)),
-    ( __param(4, ITextFileService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IConfigurationService))
-], Launch));
+Launch = ( (__decorate([
+    ( (__param(3, IFileService))),
+    ( (__param(4, ITextFileService))),
+    ( (__param(5, IEditorService))),
+    ( (__param(6, IConfigurationService)))
+], Launch)));
 let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
     constructor(configurationManager, adapterManager, editorService, configurationService, contextService) {
         super(configurationManager, adapterManager);
@@ -574,11 +578,7 @@ let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
         return this.contextService.getWorkspace().configuration;
     }
     get name() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugConfigurationManager',
-            'workspace',
-            "workspace"
-        ));
+        return ( localizeWithPath(_moduleId, 3, "workspace"));
     }
     getConfig() {
         return this.configurationService.inspect('launch').workspaceValue;
@@ -604,11 +604,11 @@ let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
         });
     }
 };
-WorkspaceLaunch = ( __decorate([
-    ( __param(2, IEditorService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IWorkspaceContextService))
-], WorkspaceLaunch));
+WorkspaceLaunch = ( (__decorate([
+    ( (__param(2, IEditorService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IWorkspaceContextService)))
+], WorkspaceLaunch)));
 let UserLaunch = class UserLaunch extends AbstractLaunch {
     constructor(configurationManager, adapterManager, configurationService, preferencesService) {
         super(configurationManager, adapterManager);
@@ -622,11 +622,7 @@ let UserLaunch = class UserLaunch extends AbstractLaunch {
         return this.preferencesService.userSettingsResource;
     }
     get name() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugConfigurationManager',
-            'user settings',
-            "user settings"
-        ));
+        return ( localizeWithPath(_moduleId, 4, "user settings"));
     }
     get hidden() {
         return true;
@@ -642,9 +638,9 @@ let UserLaunch = class UserLaunch extends AbstractLaunch {
         });
     }
 };
-UserLaunch = ( __decorate([
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IPreferencesService))
-], UserLaunch));
+UserLaunch = ( (__decorate([
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IPreferencesService)))
+], UserLaunch)));
 
 export { ConfigurationManager };

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

@@ -8,6 +8,7 @@ import { DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, SELECT_AND_START_ID } from './debugC
 import { REPL_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
 
+const _moduleId = "vs/workbench/contrib/debug/browser/debugConsoleQuickAccess";
 let DebugConsoleQuickAccess = class DebugConsoleQuickAccess extends PickerQuickAccessProvider {
     constructor(_debugService, _viewsService, _commandService) {
         super(DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, { canAcceptInBackground: true });
@@ -26,11 +27,7 @@ let DebugConsoleQuickAccess = class DebugConsoleQuickAccess extends PickerQuickA
         if (debugConsolePicks.length > 0) {
             debugConsolePicks.push({ type: 'separator' });
         }
-        const createTerminalLabel = ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/debugConsoleQuickAccess',
-            "workbench.action.debug.startDebug",
-            "Start a New Debug Session"
-        ));
+        const createTerminalLabel = ( localizeWithPath(_moduleId, 0, "Start a New Debug Session"));
         debugConsolePicks.push({
             label: `$(plus) ${createTerminalLabel}`,
             ariaLabel: createTerminalLabel,
@@ -56,10 +53,10 @@ let DebugConsoleQuickAccess = class DebugConsoleQuickAccess extends PickerQuickA
         return undefined;
     }
 };
-DebugConsoleQuickAccess = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IViewsService)),
-    ( __param(2, ICommandService))
-], DebugConsoleQuickAccess));
+DebugConsoleQuickAccess = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IViewsService))),
+    ( (__param(2, ICommandService)))
+], DebugConsoleQuickAccess)));
 
 export { DebugConsoleQuickAccess };