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

package/vscode/src/vs/workbench/contrib/debug/common/debugger.js

@@ -16,6 +16,7 @@ import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/cont
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { filter } from 'vscode/vscode/vs/base/common/objects';
 
+const _moduleId = "vs/workbench/contrib/debug/common/debugger";
 let Debugger = class Debugger {
     constructor(adapterManager, dbgContribution, extensionDescription, configurationService, resourcePropertiesService, configurationResolverService, environmentService, debugService, contextKeyService) {
         this.adapterManager = adapterManager;
@@ -37,7 +38,7 @@ let Debugger = class Debugger {
                 return source;
             }
             if (isObject(source)) {
-                ( Object.keys(source)).forEach(key => {
+                ( (Object.keys(source))).forEach(key => {
                     if (key !== '__proto__') {
                         if (isObject(destination[key]) && isObject(source[key])) {
                             mixin(destination[key], source[key], overwrite, level + 1);
@@ -78,7 +79,9 @@ let Debugger = class Debugger {
         if (da) {
             return Promise.resolve(da);
         }
-        throw new Error(localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'cannot.find.da', "Cannot find debug adapter for type '{0}'.", this.type));
+        throw ( (new Error(
+            localizeWithPath(_moduleId, 0, "Cannot find debug adapter for type '{0}'.", this.type)
+        )));
     }
     async substituteVariables(folder, config) {
         const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
@@ -137,21 +140,13 @@ let Debugger = class Debugger {
         if (initialConfigs) {
             initialConfigurations = initialConfigurations.concat(initialConfigs);
         }
-        const eol = this.resourcePropertiesService.getEOL(( URI.from({ scheme: Schemas.untitled, path: '1' }))) === '\r\n' ? '\r\n' : '\n';
-        const configs = ( JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line)).join(eol).trim();
-        const comment1 = ( localizeWithPath(
-            'vs/workbench/contrib/debug/common/debugger',
-            'launch.config.comment1',
-            "Use IntelliSense to learn about possible attributes."
-        ));
-        const comment2 = ( localizeWithPath(
-            'vs/workbench/contrib/debug/common/debugger',
-            'launch.config.comment2',
-            "Hover to view descriptions of existing attributes."
-        ));
+        const eol = this.resourcePropertiesService.getEOL(( (URI.from({ scheme: Schemas.untitled, path: '1' })))) === '\r\n' ? '\r\n' : '\n';
+        const configs = ( (JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line))).join(eol).trim();
+        const comment1 = ( localizeWithPath(_moduleId, 1, "Use IntelliSense to learn about possible attributes."));
+        const comment2 = ( localizeWithPath(_moduleId, 2, "Hover to view descriptions of existing attributes."));
         const comment3 = ( localizeWithPath(
-            'vs/workbench/contrib/debug/common/debugger',
-            'launch.config.comment3',
+            _moduleId,
+            3,
             "For more information, visit: {0}",
             'https://go.microsoft.com/fwlink/?linkid=830387'
         ));
@@ -166,7 +161,7 @@ let Debugger = class Debugger {
         ].join(eol);
         const editorConfig = this.configurationService.getValue();
         if (editorConfig.editor && editorConfig.editor.insertSpaces) {
-            content = content.replace(( new RegExp('\t', 'g')), ' '.repeat(editorConfig.editor.tabSize));
+            content = content.replace(( (new RegExp('\t', 'g'))), ' '.repeat(editorConfig.editor.tabSize));
         }
         return Promise.resolve(content);
     }
@@ -189,103 +184,89 @@ let Debugger = class Debugger {
         if (!this.debuggerContribution.configurationAttributes) {
             return null;
         }
-        return ( ( Object.keys(this.debuggerContribution.configurationAttributes)).map(request => {
-            const definitionId = `${this.type}:${request}`;
-            const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
-            const attributes = this.debuggerContribution.configurationAttributes[request];
-            const defaultRequired = ['name', 'type', 'request'];
-            attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
-            attributes.additionalProperties = false;
-            attributes.type = 'object';
-            if (!attributes.properties) {
-                attributes.properties = {};
-            }
-            const properties = attributes.properties;
-            properties['type'] = {
-                enum: [this.type],
-                enumDescriptions: [this.label],
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/common/debugger',
-                    'debugType',
-                    "Type of configuration."
-                )),
-                pattern: '^(?!node2)',
-                deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
-                doNotSuggest: !!this.debuggerContribution.deprecated,
-                errorMessage: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/common/debugger',
-                    'debugTypeNotRecognised',
-                    "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
-                )),
-                patternErrorMessage: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/common/debugger',
-                    'node2NotSupported',
-                    "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
-                ))
-            };
-            properties['request'] = {
-                enum: [request],
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/common/debugger',
-                    'debugRequest',
-                    "Request type of configuration. Can be \"launch\" or \"attach\"."
-                )),
-            };
-            for (const prop in definitions['common'].properties) {
-                properties[prop] = {
-                    $ref: `#/definitions/common/properties/${prop}`
+        return (
+             (( (Object.keys(this.debuggerContribution.configurationAttributes))).map(request => {
+                const definitionId = `${this.type}:${request}`;
+                const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
+                const attributes = this.debuggerContribution.configurationAttributes[request];
+                const defaultRequired = ['name', 'type', 'request'];
+                attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
+                attributes.additionalProperties = false;
+                attributes.type = 'object';
+                if (!attributes.properties) {
+                    attributes.properties = {};
+                }
+                const properties = attributes.properties;
+                properties['type'] = {
+                    enum: [this.type],
+                    enumDescriptions: [this.label],
+                    description: ( localizeWithPath(_moduleId, 4, "Type of configuration.")),
+                    pattern: '^(?!node2)',
+                    deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
+                    doNotSuggest: !!this.debuggerContribution.deprecated,
+                    errorMessage: ( localizeWithPath(
+                        _moduleId,
+                        5,
+                        "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
+                    )),
+                    patternErrorMessage: ( localizeWithPath(
+                        _moduleId,
+                        6,
+                        "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
+                    ))
                 };
-            }
-            ( Object.keys(properties)).forEach(name => {
-                applyDeprecatedVariableMessage(properties[name]);
-            });
-            definitions[definitionId] = { ...attributes };
-            definitions[platformSpecificDefinitionId] = {
-                type: 'object',
-                additionalProperties: false,
-                properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
-            };
-            const attributesCopy = { ...attributes };
-            attributesCopy.properties = {
-                ...properties,
-                ...{
-                    windows: {
-                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/common/debugger',
-                            'debugWindowsConfiguration',
-                            "Windows specific launch configuration attributes."
-                        )),
-                    },
-                    osx: {
-                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/common/debugger',
-                            'debugOSXConfiguration',
-                            "OS X specific launch configuration attributes."
-                        )),
-                    },
-                    linux: {
-                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/debug/common/debugger',
-                            'debugLinuxConfiguration',
-                            "Linux specific launch configuration attributes."
-                        )),
-                    }
+                properties['request'] = {
+                    enum: [request],
+                    description: ( localizeWithPath(
+                        _moduleId,
+                        7,
+                        "Request type of configuration. Can be \"launch\" or \"attach\"."
+                    )),
+                };
+                for (const prop in definitions['common'].properties) {
+                    properties[prop] = {
+                        $ref: `#/definitions/common/properties/${prop}`
+                    };
                 }
-            };
-            return attributesCopy;
-        }));
+                ( (Object.keys(properties))).forEach(name => {
+                    applyDeprecatedVariableMessage(properties[name]);
+                });
+                definitions[definitionId] = { ...attributes };
+                definitions[platformSpecificDefinitionId] = {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
+                };
+                const attributesCopy = { ...attributes };
+                attributesCopy.properties = {
+                    ...properties,
+                    ...{
+                        windows: {
+                            $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                            description: ( localizeWithPath(_moduleId, 8, "Windows specific launch configuration attributes.")),
+                        },
+                        osx: {
+                            $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                            description: ( localizeWithPath(_moduleId, 9, "OS X specific launch configuration attributes.")),
+                        },
+                        linux: {
+                            $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                            description: ( localizeWithPath(_moduleId, 10, "Linux specific launch configuration attributes.")),
+                        }
+                    }
+                };
+                return attributesCopy;
+            }))
+        );
     }
 };
-Debugger = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ITextResourcePropertiesService)),
-    ( __param(5, IConfigurationResolverService)),
-    ( __param(6, IWorkbenchEnvironmentService)),
-    ( __param(7, IDebugService)),
-    ( __param(8, IContextKeyService))
-], Debugger));
+Debugger = ( (__decorate([
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, ITextResourcePropertiesService))),
+    ( (__param(5, IConfigurationResolverService))),
+    ( (__param(6, IWorkbenchEnvironmentService))),
+    ( (__param(7, IDebugService))),
+    ( (__param(8, IContextKeyService)))
+], Debugger)));
 
 export { Debugger };

package/vscode/src/vs/workbench/contrib/debug/common/loadedScriptsPicker.js

@@ -10,6 +10,7 @@ import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { dirname } from 'vscode/vscode/vs/base/common/resources';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
 
+const _moduleId = "vs/workbench/contrib/debug/common/loadedScriptsPicker";
 async function showLoadedScriptMenu(accessor) {
     const quickInputService = accessor.get(IQuickInputService);
     const debugService = accessor.get(IDebugService);
@@ -18,15 +19,11 @@ async function showLoadedScriptMenu(accessor) {
     const modelService = accessor.get(IModelService);
     const languageService = accessor.get(ILanguageService);
     const labelService = accessor.get(ILabelService);
-    const localDisposableStore = ( new DisposableStore());
+    const localDisposableStore = ( (new DisposableStore()));
     const quickPick = quickInputService.createQuickPick();
     localDisposableStore.add(quickPick);
     quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
-    quickPick.placeholder = ( localizeWithPath(
-        'vs/workbench/contrib/debug/common/loadedScriptsPicker',
-        'moveFocusedView.selectView',
-        "Search loaded scripts by name"
-    ));
+    quickPick.placeholder = ( localizeWithPath(_moduleId, 0, "Search loaded scripts by name"));
     quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
     localDisposableStore.add(quickPick.onDidChangeValue(async () => {
         quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
@@ -53,9 +50,9 @@ async function _getPicksFromSession(session, filter, editorService, modelService
 }
 async function _getPicks(filter, sessions, editorService, modelService, languageService, labelService) {
     const loadedScriptPicks = [];
-    const picks = await Promise.all(( sessions.map(
+    const picks = await Promise.all(( (sessions.map(
         (session) => _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService)
-    )));
+    ))));
     for (const row of picks) {
         for (const elem of row) {
             loadedScriptPicks.push(elem);

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands.js

@@ -6,12 +6,9 @@ import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/cl
 import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands";
 const COPY_NOTEBOOK_VARIABLE_VALUE_ID = 'workbench.debug.viewlet.action.copyWorkspaceVariableValue';
-const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localizeWithPath(
-    'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands',
-    'copyWorkspaceVariableValue',
-    "Copy Value"
-));
+const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localizeWithPath(_moduleId, 0, "Copy Value"));
 registerAction2(class extends Action2 {
     constructor() {
         super({
@@ -31,11 +28,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: '_executeNotebookVariableProvider',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands',
-                'executeNotebookVariableProvider',
-                "Execute Notebook Variable Provider"
-            )),
+            title: ( localizeWithPath(_moduleId, 1, "Execute Notebook Variable Provider")),
             f1: false,
         });
     }
@@ -53,8 +46,8 @@ registerAction2(class extends Action2 {
         const selectedKernel = notebookKernelService.getMatchingKernel(notebookTextModel).selected;
         if (selectedKernel && selectedKernel.hasVariableProvider) {
             const variables = selectedKernel.provideVariables(notebookTextModel.uri, undefined, 'named', 0, CancellationToken.None);
-            return await ( variables
-                .map(variable => { return variable; }))
+            return await ( (variables
+                .map(variable => { return variable; })))
                 .toPromise();
         }
         return [];

package/vscode/src/vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService.js

@@ -6,6 +6,7 @@ import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
 import { AbstractVariableResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/variableResolver';
 
+const _moduleId = "vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService";
 class BaseConfigurationResolverService extends AbstractVariableResolverService {
     static { this.INPUT_OR_COMMAND_VARIABLES_PATTERN = /\${((input|command):(.*?))}/g; }
     constructor(context, envVariablesPromise, editorService, configurationService, commandService, workspaceContextService, quickInputService, labelService, pathService, extensionService) {
@@ -89,7 +90,7 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
         this.quickInputService = quickInputService;
         this.labelService = labelService;
         this.pathService = pathService;
-        this.userInputAccessQueue = ( new Queue());
+        this.userInputAccessQueue = ( (new Queue()));
     }
     async resolveWithInteractionReplace(folder, config, section, variables, target) {
         config = await this.resolveAnyAsync(folder, config);
@@ -165,12 +166,17 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                     const commandId = (variableToCommandMap ? variableToCommandMap[name] : undefined) || name;
                     result = await this.commandService.executeCommand(commandId, configuration);
                     if (typeof result !== 'string' && !isUndefinedOrNull(result)) {
-                        throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'commandVariable.noStringType', "Cannot substitute command variable '{0}' because command did not return a result of type string.", commandId));
+                        throw ( (new Error(localizeWithPath(
+                            _moduleId,
+                            0,
+                            "Cannot substitute command variable '{0}' because command did not return a result of type string.",
+                            commandId
+                        ))));
                     }
                     break;
                 }
                 default:
-                    if (( this._contributedVariables.has(variable))) {
+                    if (( (this._contributedVariables.has(variable)))) {
                         result = await this._contributedVariables.get(variable)();
                     }
             }
@@ -194,7 +200,7 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                     }
                 }
             }
-            for (const contributed of ( this._contributedVariables.keys())) {
+            for (const contributed of ( (this._contributedVariables.keys()))) {
                 if ((variables.indexOf(contributed) < 0) && (object.indexOf('${' + contributed + '}') >= 0)) {
                     variables.push(contributed);
                 }
@@ -206,25 +212,32 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
             }
         }
         else if (object) {
-            for (const value of ( Object.values(object))) {
+            for (const value of ( (Object.values(object)))) {
                 this.findVariables(value, variables);
             }
         }
     }
     showUserInput(variable, inputInfos) {
         if (!inputInfos) {
-            return Promise.reject(( new Error(( localizeWithPath(
-                'vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService',
-                'inputVariable.noInputSection',
+            return Promise.reject(( (new Error(( localizeWithPath(
+                _moduleId,
+                1,
                 "Variable '{0}' must be defined in an '{1}' section of the debug or task configuration.",
                 variable,
                 'input'
-            )))));
+            ))))));
         }
         const info = inputInfos.filter(item => item.id === variable).pop();
         if (info) {
             const missingAttribute = (attrName) => {
-                throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.missingAttribute', "Input variable '{0}' is of type '{1}' and must include '{2}'.", variable, info.type, attrName));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    2,
+                    "Input variable '{0}' is of type '{1}' and must include '{2}'.",
+                    variable,
+                    info.type,
+                    attrName
+                ))));
             };
             switch (info.type) {
                 case 'promptString': {
@@ -256,7 +269,7 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                     else {
                         missingAttribute('options');
                     }
-                    const picks = ( new Array());
+                    const picks = ( (new Array()));
                     for (const pickOption of info.options) {
                         const value = isString(pickOption) ? pickOption : pickOption.value;
                         const label = isString(pickOption) ? undefined : pickOption.label;
@@ -265,11 +278,7 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                             value: value
                         };
                         if (value === info.default) {
-                            item.description = ( localizeWithPath(
-                                'vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService',
-                                'inputVariable.defaultInputValue',
-                                "(Default)"
-                            ));
+                            item.description = ( localizeWithPath(_moduleId, 3, "(Default)"));
                             picks.unshift(item);
                         }
                         else {
@@ -292,19 +301,30 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                         if (typeof result === 'string' || isUndefinedOrNull(result)) {
                             return result;
                         }
-                        throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.command.noStringType', "Cannot substitute input variable '{0}' because command '{1}' did not return a result of type string.", variable, info.command));
+                        throw ( (new Error(localizeWithPath(
+                            _moduleId,
+                            4,
+                            "Cannot substitute input variable '{0}' because command '{1}' did not return a result of type string.",
+                            variable,
+                            info.command
+                        ))));
                     });
                 }
                 default:
-                    throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.unknownType', "Input variable '{0}' can only be of type 'promptString', 'pickString', or 'command'.", variable));
+                    throw ( (new Error(localizeWithPath(
+                        _moduleId,
+                        5,
+                        "Input variable '{0}' can only be of type 'promptString', 'pickString', or 'command'.",
+                        variable
+                    ))));
             }
         }
-        return Promise.reject(( new Error(( localizeWithPath(
-            'vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService',
-            'inputVariable.undefinedVariable',
+        return Promise.reject(( (new Error(( localizeWithPath(
+            _moduleId,
+            6,
             "Undefined input variable '{0}' encountered. Remove or define '{0}' to continue.",
             variable
-        )))));
+        ))))));
     }
 }